add INLINE pragmas
authorRoss Paterson <ross@soi.city.ac.uk>
Tue, 16 Feb 2016 11:07:58 +0000 (11:07 +0000)
committerRoss Paterson <ross@soi.city.ac.uk>
Tue, 16 Feb 2016 11:07:58 +0000 (11:07 +0000)
(suggested by Oliver Charles)

16 files changed:
Control/Applicative/Backwards.hs
Control/Applicative/Lift.hs
Control/Monad/Trans/Cont.hs
Control/Monad/Trans/Except.hs
Control/Monad/Trans/Identity.hs
Control/Monad/Trans/List.hs
Control/Monad/Trans/Maybe.hs
Control/Monad/Trans/RWS/Lazy.hs
Control/Monad/Trans/RWS/Strict.hs
Control/Monad/Trans/Reader.hs
Control/Monad/Trans/State/Lazy.hs
Control/Monad/Trans/State/Strict.hs
Control/Monad/Trans/Writer/Lazy.hs
Control/Monad/Trans/Writer/Strict.hs
Data/Functor/Constant.hs
Data/Functor/Reverse.hs

index ae6715b..16e9fe9 100644 (file)
@@ -39,9 +39,11 @@ newtype Backwards f a = Backwards { forwards :: f a }
 
 instance (Eq1 f) => Eq1 (Backwards f) where
     liftEq eq (Backwards x) (Backwards y) = liftEq eq x y
+    {-# INLINE liftEq #-}
 
 instance (Ord1 f) => Ord1 (Backwards f) where
     liftCompare comp (Backwards x) (Backwards y) = liftCompare comp x y
+    {-# INLINE liftCompare #-}
 
 instance (Read1 f) => Read1 (Backwards f) where
     liftReadsPrec rp rl = readsData $
@@ -59,26 +61,38 @@ instance (Show1 f, Show a) => Show (Backwards f a) where showsPrec = showsPrec1
 -- | Derived instance.
 instance (Functor f) => Functor (Backwards f) where
     fmap f (Backwards a) = Backwards (fmap f a)
+    {-# INLINE fmap #-}
 
 -- | Apply @f@-actions in the reverse order.
 instance (Applicative f) => Applicative (Backwards f) where
     pure a = Backwards (pure a)
+    {-# INLINE pure #-}
     Backwards f <*> Backwards a = Backwards (a <**> f)
+    {-# INLINE (<*>) #-}
 
 -- | Try alternatives in the same order as @f@.
 instance (Alternative f) => Alternative (Backwards f) where
     empty = Backwards empty
+    {-# INLINE empty #-}
     Backwards x <|> Backwards y = Backwards (x <|> y)
+    {-# INLINE (<|>) #-}
 
 -- | Derived instance.
 instance (Foldable f) => Foldable (Backwards f) where
     foldMap f (Backwards t) = foldMap f t
+    {-# INLINE foldMap #-}
     foldr f z (Backwards t) = foldr f z t
+    {-# INLINE foldr #-}
     foldl f z (Backwards t) = foldl f z t
+    {-# INLINE foldl #-}
     foldr1 f (Backwards t) = foldr1 f t
+    {-# INLINE foldr1 #-}
     foldl1 f (Backwards t) = foldl1 f t
+    {-# INLINE foldl1 #-}
 
 -- | Derived instance.
 instance (Traversable f) => Traversable (Backwards f) where
     traverse f (Backwards t) = fmap Backwards (traverse f t)
+    {-# INLINE traverse #-}
     sequenceA (Backwards t) = fmap Backwards (sequenceA t)
+    {-# INLINE sequenceA #-}
index dc654c8..71ee6aa 100644 (file)
@@ -46,12 +46,14 @@ instance (Eq1 f) => Eq1 (Lift f) where
     liftEq _ (Pure _) (Other _) = False
     liftEq _ (Other _) (Pure _) = False
     liftEq eq (Other y1) (Other y2) = liftEq eq y1 y2
+    {-# INLINE liftEq #-}
 
 instance (Ord1 f) => Ord1 (Lift f) where
     liftCompare comp (Pure x1) (Pure x2) = comp x1 x2
     liftCompare _ (Pure _) (Other _) = LT
     liftCompare _ (Other _) (Pure _) = GT
     liftCompare comp (Other y1) (Other y2) = liftCompare comp y1 y2
+    {-# INLINE liftCompare #-}
 
 instance (Read1 f) => Read1 (Lift f) where
     liftReadsPrec rp rl = readsData $
@@ -71,39 +73,48 @@ instance (Show1 f, Show a) => Show (Lift f a) where showsPrec = showsPrec1
 instance (Functor f) => Functor (Lift f) where
     fmap f (Pure x) = Pure (f x)
     fmap f (Other y) = Other (fmap f y)
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (Lift f) where
     foldMap f (Pure x) = f x
     foldMap f (Other y) = foldMap f y
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (Lift f) where
     traverse f (Pure x) = Pure <$> f x
     traverse f (Other y) = Other <$> traverse f y
+    {-# INLINE traverse #-}
 
 -- | A combination is 'Pure' only if both parts are.
 instance (Applicative f) => Applicative (Lift f) where
     pure = Pure
+    {-# INLINE pure #-}
     Pure f <*> Pure x = Pure (f x)
     Pure f <*> Other y = Other (f <$> y)
     Other f <*> Pure x = Other (($ x) <$> f)
     Other f <*> Other y = Other (f <*> y)
+    {-# INLINE (<*>) #-}
 
 -- | A combination is 'Pure' only either part is.
 instance (Alternative f) => Alternative (Lift f) where
     empty = Other empty
+    {-# INLINE empty #-}
     Pure x <|> _ = Pure x
     Other _ <|> Pure y = Pure y
     Other x <|> Other y = Other (x <|> y)
+    {-# INLINE (<|>) #-}
 
 -- | Projection to the other functor.
 unLift :: (Applicative f) => Lift f a -> f a
 unLift (Pure x) = pure x
 unLift (Other e) = e
+{-# INLINE unLift #-}
 
 -- | Apply a transformation to the other computation.
 mapLift :: (f a -> g a) -> Lift f a -> Lift g a
 mapLift _ (Pure x) = Pure x
 mapLift f (Other e) = Other (f e)
+{-# INLINE mapLift #-}
 
 -- | An applicative functor that collects a monoid (e.g. lists) of errors.
 -- A sequence of computations fails if any of its components do, but
@@ -129,7 +140,9 @@ type Errors e = Lift (Constant e)
 runErrors :: Errors e a -> Either e a
 runErrors (Other (Constant e)) = Left e
 runErrors (Pure x) = Right x
+{-# INLINE runErrors #-}
 
 -- | Report an error.
 failure :: e -> Errors e a
 failure e = Other (Constant e)
+{-# INLINE failure #-}
index 4a4afea..141734d 100644 (file)
@@ -72,6 +72,7 @@ type Cont r = ContT r Identity
 -- (The inverse of 'runCont')
 cont :: ((a -> r) -> r) -> Cont r a
 cont f = ContT (\ c -> Identity (f (runIdentity . c)))
+{-# INLINE cont #-}
 
 -- | The result of running a CPS computation with a given final continuation.
 -- (The inverse of 'cont')
@@ -81,6 +82,7 @@ runCont
                         -- the final result (often 'id').
     -> r
 runCont m k = runIdentity (runContT m (Identity . k))
+{-# INLINE runCont #-}
 
 -- | The result of running a CPS computation with the identity as the
 -- final continuation.
@@ -88,6 +90,7 @@ runCont m k = runIdentity (runContT m (Identity . k))
 -- * @'evalCont' ('return' x) = x@
 evalCont :: Cont r r -> r
 evalCont m = runIdentity (evalContT m)
+{-# INLINE evalCont #-}
 
 -- | Apply a function to transform the result of a continuation-passing
 -- computation.
@@ -95,6 +98,7 @@ evalCont m = runIdentity (evalContT m)
 -- * @'runCont' ('mapCont' f m) = f . 'runCont' m@
 mapCont :: (r -> r) -> Cont r a -> Cont r a
 mapCont f = mapContT (Identity . f . runIdentity)
+{-# INLINE mapCont #-}
 
 -- | Apply a function to transform the continuation passed to a CPS
 -- computation.
@@ -102,6 +106,7 @@ mapCont f = mapContT (Identity . f . runIdentity)
 -- * @'runCont' ('withCont' f m) = 'runCont' m . f@
 withCont :: ((b -> r) -> (a -> r)) -> Cont r a -> Cont r b
 withCont f = withContT ((Identity .) . f . (runIdentity .))
+{-# INLINE withCont #-}
 
 -- | @'reset' m@ delimits the continuation of any 'shift' inside @m@.
 --
@@ -109,6 +114,7 @@ withCont f = withContT ((Identity .) . f . (runIdentity .))
 --
 reset :: Cont r r -> Cont r' r
 reset = resetT
+{-# INLINE reset #-}
 
 -- | @'shift' f@ captures the continuation up to the nearest enclosing
 -- 'reset' and passes it to @f@:
@@ -117,6 +123,7 @@ reset = resetT
 --
 shift :: ((a -> r) -> Cont r r) -> Cont r a
 shift f = shiftT (f . (runIdentity .))
+{-# INLINE shift #-}
 
 -- | The continuation monad transformer.
 -- Can be used to add continuation handling to any type constructor:
@@ -133,6 +140,7 @@ newtype ContT r m a = ContT { runContT :: (a -> m r) -> m r }
 -- * @'evalContT' ('lift' m) = m@
 evalContT :: (Monad m) => ContT r m r -> m r
 evalContT m = runContT m return
+{-# INLINE evalContT #-}
 
 -- | Apply a function to transform the result of a continuation-passing
 -- computation.  This has a more restricted type than the @map@ operations
@@ -142,6 +150,7 @@ evalContT m = runContT m return
 -- * @'runContT' ('mapContT' f m) = f . 'runContT' m@
 mapContT :: (m r -> m r) -> ContT r m a -> ContT r m a
 mapContT f m = ContT $ f . runContT m
+{-# INLINE mapContT #-}
 
 -- | Apply a function to transform the continuation passed to a CPS
 -- computation.
@@ -149,30 +158,39 @@ mapContT f m = ContT $ f . runContT m
 -- * @'runContT' ('withContT' f m) = 'runContT' m . f@
 withContT :: ((b -> m r) -> (a -> m r)) -> ContT r m a -> ContT r m b
 withContT f m = ContT $ runContT m . f
+{-# INLINE withContT #-}
 
 instance Functor (ContT r m) where
     fmap f m = ContT $ \ c -> runContT m (c . f)
+    {-# INLINE fmap #-}
 
 instance Applicative (ContT r m) where
     pure x  = ContT ($ x)
+    {-# INLINE pure #-}
     f <*> v = ContT $ \ c -> runContT f $ \ g -> runContT v (c . g)
+    {-# INLINE (<*>) #-}
 
 instance Monad (ContT r m) where
 #if !(MIN_VERSION_base(4,8,0))
     return x = ContT ($ x)
+    {-# INLINE return #-}
 #endif
     m >>= k  = ContT $ \ c -> runContT m (\ x -> runContT (k x) c)
+    {-# INLINE (>>=) #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (ContT r m) where
     fail msg = ContT $ \ _ -> Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance MonadTrans (ContT r) where
     lift m = ContT (m >>=)
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (ContT r m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 -- | @callCC@ (call-with-current-continuation) calls its argument
 -- function, passing it the current continuation.  It provides
@@ -191,6 +209,7 @@ instance (MonadIO m) => MonadIO (ContT r m) where
 -- layers deep within nested computations.
 callCC :: ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
 callCC f = ContT $ \ c -> runContT (f (\ x -> ContT $ \ _ -> c x)) c
+{-# INLINE callCC #-}
 
 -- | @'resetT' m@ delimits the continuation of any 'shiftT' inside @m@.
 --
@@ -198,6 +217,7 @@ callCC f = ContT $ \ c -> runContT (f (\ x -> ContT $ \ _ -> c x)) c
 --
 resetT :: (Monad m) => ContT r m r -> ContT r' m r
 resetT = lift . evalContT
+{-# INLINE resetT #-}
 
 -- | @'shiftT' f@ captures the continuation up to the nearest enclosing
 -- 'resetT' and passes it to @f@:
@@ -206,6 +226,7 @@ resetT = lift . evalContT
 --
 shiftT :: (Monad m) => ((a -> m r) -> ContT r m r) -> ContT r m a
 shiftT f = ContT (evalContT . f)
+{-# INLINE shiftT #-}
 
 -- | @'liftLocal' ask local@ yields a @local@ function for @'ContT' r m@.
 liftLocal :: (Monad m) => m r' -> ((r' -> r') -> m r -> m r) ->
@@ -213,3 +234,4 @@ liftLocal :: (Monad m) => m r' -> ((r' -> r') -> m r -> m r) ->
 liftLocal ask local f m = ContT $ \ c -> do
     r <- ask
     local f (runContT m (local (const r) . c))
+{-# INLINE liftLocal #-}
index 1e71188..daa43cc 100644 (file)
@@ -79,11 +79,13 @@ type Except e = ExceptT e Identity
 -- (The inverse of 'runExcept').
 except :: Either e a -> Except e a
 except m = ExceptT (Identity m)
+{-# INLINE except #-}
 
 -- | Extractor for computations in the exception monad.
 -- (The inverse of 'except').
 runExcept :: Except e a -> Either e a
 runExcept (ExceptT m) = runIdentity m
+{-# INLINE runExcept #-}
 
 -- | Map the unwrapped computation using the given function.
 --
@@ -92,11 +94,13 @@ mapExcept :: (Either e a -> Either e' b)
         -> Except e a
         -> Except e' b
 mapExcept f = mapExceptT (Identity . f . runIdentity)
+{-# INLINE mapExcept #-}
 
 -- | Transform any exceptions thrown by the computation using the given
 -- function (a specialization of 'withExceptT').
 withExcept :: (e -> e') -> Except e a -> Except e' a
 withExcept = withExceptT
+{-# INLINE withExcept #-}
 
 -- | A monad transformer that adds exceptions to other monads.
 --
@@ -113,10 +117,12 @@ newtype ExceptT e m a = ExceptT (m (Either e a))
 
 instance (Eq e, Eq1 m) => Eq1 (ExceptT e m) where
     liftEq eq (ExceptT x) (ExceptT y) = liftEq (liftEq eq) x y
+    {-# INLINE liftEq #-}
 
 instance (Ord e, Ord1 m) => Ord1 (ExceptT e m) where
     liftCompare comp (ExceptT x) (ExceptT y) =
         liftCompare (liftCompare comp) x y
+    {-# INLINE liftCompare #-}
 
 instance (Read e, Read1 m) => Read1 (ExceptT e m) where
     liftReadsPrec rp rl = readsData $
@@ -132,8 +138,10 @@ instance (Show e, Show1 m) => Show1 (ExceptT e m) where
         sp' = liftShowsPrec sp sl
         sl' = liftShowList sp sl
 
-instance (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) where (==) = eq1
-instance (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) where compare = compare1
+instance (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
+    where (==) = eq1
+instance (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)
+    where compare = compare1
 instance (Read e, Read1 m, Read a) => Read (ExceptT e m a) where
     readsPrec = readsPrec1
 instance (Show e, Show1 m, Show a) => Show (ExceptT e m a) where
@@ -142,6 +150,7 @@ instance (Show e, Show1 m, Show a) => Show (ExceptT e m a) where
 -- | The inverse of 'ExceptT'.
 runExceptT :: ExceptT e m a -> m (Either e a)
 runExceptT (ExceptT m) = m
+{-# INLINE runExceptT #-}
 
 -- | Map the unwrapped computation using the given function.
 --
@@ -150,24 +159,30 @@ mapExceptT :: (m (Either e a) -> n (Either e' b))
         -> ExceptT e m a
         -> ExceptT e' n b
 mapExceptT f m = ExceptT $ f (runExceptT m)
+{-# INLINE mapExceptT #-}
 
 -- | Transform any exceptions thrown by the computation using the
 -- given function.
 withExceptT :: (Functor m) => (e -> e') -> ExceptT e m a -> ExceptT e' m a
 withExceptT f = mapExceptT $ fmap $ either (Left . f) Right
+{-# INLINE withExceptT #-}
 
 instance (Functor m) => Functor (ExceptT e m) where
     fmap f = ExceptT . fmap (fmap f) . runExceptT
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (ExceptT e f) where
     foldMap f (ExceptT a) = foldMap (either (const mempty) f) a
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (ExceptT e f) where
     traverse f (ExceptT a) =
         ExceptT <$> traverse (either (pure . Left) (fmap Right . f)) a
+    {-# INLINE traverse #-}
 
 instance (Functor m, Monad m) => Applicative (ExceptT e m) where
     pure a = ExceptT $ return (Right a)
+    {-# INLINE pure #-}
     ExceptT f <*> ExceptT v = ExceptT $ do
         mf <- f
         case mf of
@@ -177,52 +192,65 @@ instance (Functor m, Monad m) => Applicative (ExceptT e m) where
                 case mv of
                     Left e -> return (Left e)
                     Right x -> return (Right (k x))
+    {-# INLINEABLE (<*>) #-}
 
 instance (Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) where
     empty = ExceptT $ return (Left mempty)
+    {-# INLINE empty #-}
     ExceptT mx <|> ExceptT my = ExceptT $ do
         ex <- mx
         case ex of
             Left e -> liftM (either (Left . mappend e) Right) my
             Right x -> return (Right x)
+    {-# INLINEABLE (<|>) #-}
 
 instance (Monad m) => Monad (ExceptT e m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = ExceptT $ return (Right a)
+    {-# INLINE return #-}
 #endif
     m >>= k = ExceptT $ do
         a <- runExceptT m
         case a of
             Left e -> return (Left e)
             Right x -> runExceptT (k x)
+    {-# INLINE (>>=) #-}
     fail = ExceptT . fail
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (ExceptT e m) where
     fail = ExceptT . Fail.fail
+    {-# INLINE fail #-}
 #endif
 
 instance (Monad m, Monoid e) => MonadPlus (ExceptT e m) where
     mzero = ExceptT $ return (Left mempty)
+    {-# INLINE mzero #-}
     ExceptT mx `mplus` ExceptT my = ExceptT $ do
         ex <- mx
         case ex of
             Left e -> liftM (either (Left . mappend e) Right) my
             Right x -> return (Right x)
+    {-# INLINEABLE mplus #-}
 
 instance (MonadFix m) => MonadFix (ExceptT e m) where
     mfix f = ExceptT (mfix (runExceptT . f . either (const bomb) id))
       where bomb = error "mfix (ExceptT): inner computation returned Left value"
+    {-# INLINE mfix #-}
 
 instance MonadTrans (ExceptT e) where
     lift = ExceptT . liftM Right
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (ExceptT e m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (MonadZip m) => MonadZip (ExceptT e m) where
     mzipWith f (ExceptT a) (ExceptT b) = ExceptT $ mzipWith (liftA2 f) a b
+    {-# INLINE mzipWith #-}
 #endif
 
 -- | Signal an exception value @e@.
@@ -232,6 +260,7 @@ instance (MonadZip m) => MonadZip (ExceptT e m) where
 -- * @'throwE' e >>= m = 'throwE' e@
 throwE :: (Monad m) => e -> ExceptT e m a
 throwE = ExceptT . return . Left
+{-# INLINE throwE #-}
 
 -- | Handle an exception.
 --
@@ -248,18 +277,21 @@ m `catchE` h = ExceptT $ do
     case a of
         Left  l -> runExceptT (h l)
         Right r -> return (Right r)
+{-# INLINE catchE #-}
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b
 liftCallCC callCC f = ExceptT $
     callCC $ \ c ->
     runExceptT (f (\ a -> ExceptT $ c (Right a)))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @listen@ operation to the new monad.
 liftListen :: (Monad m) => Listen w m (Either e a) -> Listen w (ExceptT e m) a
 liftListen listen = mapExceptT $ \ m -> do
     (a, w) <- listen m
     return $! fmap (\ r -> (r, w)) a
+{-# INLINE liftListen #-}
 
 -- | Lift a @pass@ operation to the new monad.
 liftPass :: (Monad m) => Pass w m (Either e a) -> Pass w (ExceptT e m) a
@@ -268,3 +300,4 @@ liftPass pass = mapExceptT $ \ m -> pass $ do
     return $! case a of
         Left l -> (Left l, id)
         Right (r, f) -> (Right r, f)
+{-# INLINE liftPass #-}
index 41c4cfa..77a9050 100644 (file)
@@ -54,9 +54,11 @@ newtype IdentityT f a = IdentityT { runIdentityT :: f a }
 
 instance (Eq1 f) => Eq1 (IdentityT f) where
     liftEq eq (IdentityT x) (IdentityT y) = liftEq eq x y
+    {-# INLINE liftEq #-}
 
 instance (Ord1 f) => Ord1 (IdentityT f) where
     liftCompare comp (IdentityT x) (IdentityT y) = liftCompare comp x y
+    {-# INLINE liftCompare #-}
 
 instance (Read1 f) => Read1 (IdentityT f) where
     liftReadsPrec rp rl = readsData $
@@ -73,65 +75,86 @@ instance (Show1 f, Show a) => Show (IdentityT f a) where showsPrec = showsPrec1
 
 instance (Functor m) => Functor (IdentityT m) where
     fmap f = mapIdentityT (fmap f)
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (IdentityT f) where
     foldMap f (IdentityT a) = foldMap f a
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (IdentityT f) where
     traverse f (IdentityT a) = IdentityT <$> traverse f a
+    {-# INLINE traverse #-}
 
 instance (Applicative m) => Applicative (IdentityT m) where
     pure x = IdentityT (pure x)
+    {-# INLINE pure #-}
     (<*>) = lift2IdentityT (<*>)
+    {-# INLINE (<*>) #-}
 
 instance (Alternative m) => Alternative (IdentityT m) where
     empty = IdentityT empty
+    {-# INLINE empty #-}
     (<|>) = lift2IdentityT (<|>)
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (IdentityT m) where
 #if !(MIN_VERSION_base(4,8,0))
     return = IdentityT . return
+    {-# INLINE return #-}
 #endif
     m >>= k = IdentityT $ runIdentityT . k =<< runIdentityT m
+    {-# INLINE (>>=) #-}
     fail msg = IdentityT $ fail msg
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (IdentityT m) where
     fail msg = IdentityT $ Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance (MonadPlus m) => MonadPlus (IdentityT m) where
     mzero = IdentityT mzero
+    {-# INLINE mzero #-}
     mplus = lift2IdentityT mplus
+    {-# INLINE mplus #-}
 
 instance (MonadFix m) => MonadFix (IdentityT m) where
     mfix f = IdentityT (mfix (runIdentityT . f))
+    {-# INLINE mfix #-}
 
 instance (MonadIO m) => MonadIO (IdentityT m) where
     liftIO = IdentityT . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (MonadZip m) => MonadZip (IdentityT m) where
     mzipWith f = lift2IdentityT (mzipWith f)
+    {-# INLINE mzipWith #-}
 #endif
 
 instance MonadTrans IdentityT where
     lift = IdentityT
+    {-# INLINE lift #-}
 
 -- | Lift a unary operation to the new monad.
 mapIdentityT :: (m a -> n b) -> IdentityT m a -> IdentityT n b
 mapIdentityT f = IdentityT . f . runIdentityT
+{-# INLINE mapIdentityT #-}
 
 -- | Lift a binary operation to the new monad.
 lift2IdentityT ::
     (m a -> n b -> p c) -> IdentityT m a -> IdentityT n b -> IdentityT p c
 lift2IdentityT f a b = IdentityT (f (runIdentityT a) (runIdentityT b))
+{-# INLINE lift2IdentityT #-}
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: CallCC m a b -> CallCC (IdentityT m) a b
 liftCallCC callCC f =
     IdentityT $ callCC $ \ c -> runIdentityT (f (IdentityT . c))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m a -> Catch e (IdentityT m) a
 liftCatch f m h = IdentityT $ f (runIdentityT m) (runIdentityT . h)
+{-# INLINE liftCatch #-}
index 3730a25..3bbac8b 100644 (file)
@@ -52,9 +52,11 @@ newtype ListT m a = ListT { runListT :: m [a] }
 
 instance (Eq1 m) => Eq1 (ListT m) where
     liftEq eq (ListT x) (ListT y) = liftEq (liftEq eq) x y
+    {-# INLINE liftEq #-}
 
 instance (Ord1 m) => Ord1 (ListT m) where
     liftCompare comp (ListT x) (ListT y) = liftCompare (liftCompare comp) x y
+    {-# INLINE liftCompare #-}
 
 instance (Read1 m) => Read1 (ListT m) where
     liftReadsPrec rp rl = readsData $
@@ -80,57 +82,74 @@ instance (Show1 m, Show a) => Show (ListT m a) where showsPrec = showsPrec1
 -- * @'runListT' ('mapListT' f m) = f ('runListT' m)@
 mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
 mapListT f m = ListT $ f (runListT m)
+{-# INLINE mapListT #-}
 
 instance (Functor m) => Functor (ListT m) where
     fmap f = mapListT $ fmap $ map f
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (ListT f) where
     foldMap f (ListT a) = foldMap (foldMap f) a
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (ListT f) where
     traverse f (ListT a) = ListT <$> traverse (traverse f) a
+    {-# INLINE traverse #-}
 
 instance (Applicative m) => Applicative (ListT m) where
     pure a  = ListT $ pure [a]
+    {-# INLINE pure #-}
     f <*> v = ListT $ (<*>) <$> runListT f <*> runListT v
+    {-# INLINE (<*>) #-}
 
 instance (Applicative m) => Alternative (ListT m) where
     empty   = ListT $ pure []
+    {-# INLINE empty #-}
     m <|> n = ListT $ (++) <$> runListT m <*> runListT n
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (ListT m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = ListT $ return [a]
+    {-# INLINE return #-}
 #endif
     m >>= k  = ListT $ do
         a <- runListT m
         b <- mapM (runListT . k) a
         return (concat b)
+    {-# INLINE (>>=) #-}
     fail _ = ListT $ return []
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monad m) => Fail.MonadFail (ListT m) where
     fail _ = ListT $ return []
+    {-# INLINE fail #-}
 #endif
 
 instance (Monad m) => MonadPlus (ListT m) where
     mzero       = ListT $ return []
+    {-# INLINE mzero #-}
     m `mplus` n = ListT $ do
         a <- runListT m
         b <- runListT n
         return (a ++ b)
+    {-# INLINE mplus #-}
 
 instance MonadTrans ListT where
     lift m = ListT $ do
         a <- m
         return [a]
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (ListT m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (MonadZip m) => MonadZip (ListT m) where
     mzipWith f (ListT a) (ListT b) = ListT $ mzipWith (zipWith f) a b
+    {-# INLINE mzipWith #-}
 #endif
 
 -- | Lift a @callCC@ operation to the new monad.
@@ -138,8 +157,10 @@ liftCallCC :: CallCC m [a] [b] -> CallCC (ListT m) a b
 liftCallCC callCC f = ListT $
     callCC $ \ c ->
     runListT (f (\ a -> ListT $ c [a]))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m [a] -> Catch e (ListT m) a
 liftCatch catchE m h = ListT $ runListT m
     `catchE` \ e -> runListT (h e)
+{-# INLINE liftCatch #-}
index 9931979..67700fc 100644 (file)
@@ -71,9 +71,11 @@ newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
 
 instance (Eq1 m) => Eq1 (MaybeT m) where
     liftEq eq (MaybeT x) (MaybeT y) = liftEq (liftEq eq) x y
+    {-# INLINE liftEq #-}
 
 instance (Ord1 m) => Ord1 (MaybeT m) where
     liftCompare comp (MaybeT x) (MaybeT y) = liftCompare (liftCompare comp) x y
+    {-# INLINE liftCompare #-}
 
 instance (Read1 m) => Read1 (MaybeT m) where
     liftReadsPrec rp rl = readsData $
@@ -99,28 +101,35 @@ instance (Show1 m, Show a) => Show (MaybeT m a) where showsPrec = showsPrec1
 -- * @'runMaybeT' ('mapMaybeT' f m) = f ('runMaybeT' m)@
 mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
 mapMaybeT f = MaybeT . f . runMaybeT
+{-# INLINE mapMaybeT #-}
 
 -- | Convert a 'MaybeT' computation to 'ExceptT', with a default
 -- exception value.
 maybeToExceptT :: (Functor m) => e -> MaybeT m a -> ExceptT e m a
 maybeToExceptT e (MaybeT m) = ExceptT $ fmap (maybe (Left e) Right) m
+{-# INLINE maybeToExceptT #-}
 
 -- | Convert a 'ExceptT' computation to 'MaybeT', discarding the
 -- value of any exception.
 exceptToMaybeT :: (Functor m) => ExceptT e m a -> MaybeT m a
 exceptToMaybeT (ExceptT m) = MaybeT $ fmap (either (const Nothing) Just) m
+{-# INLINE exceptToMaybeT #-}
 
 instance (Functor m) => Functor (MaybeT m) where
     fmap f = mapMaybeT (fmap (fmap f))
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (MaybeT f) where
     foldMap f (MaybeT a) = foldMap (foldMap f) a
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (MaybeT f) where
     traverse f (MaybeT a) = MaybeT <$> traverse (traverse f) a
+    {-# INLINE traverse #-}
 
 instance (Functor m, Monad m) => Applicative (MaybeT m) where
     pure = lift . return
+    {-# INLINE pure #-}
     mf <*> mx = MaybeT $ do
         mb_f <- runMaybeT mf
         case mb_f of
@@ -130,68 +139,84 @@ instance (Functor m, Monad m) => Applicative (MaybeT m) where
                 case mb_x of
                     Nothing -> return Nothing
                     Just x  -> return (Just (f x))
+    {-# INLINE (<*>) #-}
 
 instance (Functor m, Monad m) => Alternative (MaybeT m) where
     empty = MaybeT (return Nothing)
+    {-# INLINE empty #-}
     x <|> y = MaybeT $ do
         v <- runMaybeT x
         case v of
             Nothing -> runMaybeT y
             Just _  -> return v
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (MaybeT m) where
 #if !(MIN_VERSION_base(4,8,0))
     return = lift . return
+    {-# INLINE return #-}
 #endif
     x >>= f = MaybeT $ do
         v <- runMaybeT x
         case v of
             Nothing -> return Nothing
             Just y  -> runMaybeT (f y)
+    {-# INLINE (>>=) #-}
     fail _ = MaybeT (return Nothing)
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monad m) => Fail.MonadFail (MaybeT m) where
     fail _ = MaybeT (return Nothing)
+    {-# INLINE fail #-}
 #endif
 
 instance (Monad m) => MonadPlus (MaybeT m) where
     mzero = MaybeT (return Nothing)
+    {-# INLINE mzero #-}
     mplus x y = MaybeT $ do
         v <- runMaybeT x
         case v of
             Nothing -> runMaybeT y
             Just _  -> return v
+    {-# INLINE mplus #-}
 
 instance (MonadFix m) => MonadFix (MaybeT m) where
     mfix f = MaybeT (mfix (runMaybeT . f . fromMaybe bomb))
       where bomb = error "mfix (MaybeT): inner computation returned Nothing"
+    {-# INLINE mfix #-}
 
 instance MonadTrans MaybeT where
     lift = MaybeT . liftM Just
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (MaybeT m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (MonadZip m) => MonadZip (MaybeT m) where
     mzipWith f (MaybeT a) (MaybeT b) = MaybeT $ mzipWith (liftA2 f) a b
+    {-# INLINE mzipWith #-}
 #endif
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b
 liftCallCC callCC f =
     MaybeT $ callCC $ \ c -> runMaybeT (f (MaybeT . c . Just))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a
 liftCatch f m h = MaybeT $ f (runMaybeT m) (runMaybeT . h)
+{-# INLINE liftCatch #-}
 
 -- | Lift a @listen@ operation to the new monad.
 liftListen :: (Monad m) => Listen w m (Maybe a) -> Listen w (MaybeT m) a
 liftListen listen = mapMaybeT $ \ m -> do
     (a, w) <- listen m
     return $! fmap (\ r -> (r, w)) a
+{-# INLINE liftListen #-}
 
 -- | Lift a @pass@ operation to the new monad.
 liftPass :: (Monad m) => Pass w m (Maybe a) -> Pass w (MaybeT m) a
@@ -200,3 +225,4 @@ liftPass pass = mapMaybeT $ \ m -> pass $ do
     return $! case a of
         Nothing     -> (Nothing, id)
         Just (v, f) -> (Just v, f)
+{-# INLINE liftPass #-}
index 19b9d8d..36694c5 100644 (file)
@@ -81,11 +81,13 @@ type RWS r w s = RWST r w s Identity
 -- (The inverse of 'runRWS'.)
 rws :: (r -> s -> (a, s, w)) -> RWS r w s a
 rws f = RWST (\ r s -> Identity (f r s))
+{-# INLINE rws #-}
 
 -- | Unwrap an RWS computation as a function.
 -- (The inverse of 'rws'.)
 runRWS :: RWS r w s a -> r -> s -> (a, s, w)
 runRWS m r s = runIdentity (runRWST m r s)
+{-# INLINE runRWS #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final value and output, discarding the final state.
@@ -96,6 +98,7 @@ evalRWS :: RWS r w s a  -- ^RWS computation to execute
 evalRWS m r s = let
     (a, _, w) = runRWS m r s
     in (a, w)
+{-# INLINE evalRWS #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final state and output, discarding the final value.
@@ -106,6 +109,7 @@ execRWS :: RWS r w s a  -- ^RWS computation to execute
 execRWS m r s = let
     (_, s', w) = runRWS m r s
     in (s', w)
+{-# INLINE execRWS #-}
 
 -- | Map the return value, final state and output of a computation using
 -- the given function.
@@ -113,6 +117,7 @@ execRWS m r s = let
 -- * @'runRWS' ('mapRWS' f m) r s = f ('runRWS' m r s)@
 mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b
 mapRWS f = mapRWST (Identity . f . runIdentity)
+{-# INLINE mapRWS #-}
 
 -- | @'withRWS' f m@ executes action @m@ with an initial environment
 -- and state modified by applying @f@.
@@ -120,6 +125,7 @@ mapRWS f = mapRWST (Identity . f . runIdentity)
 -- * @'runRWS' ('withRWS' f m) r s = 'uncurry' ('runRWS' m) (f r s)@
 withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a
 withRWS = withRWST
+{-# INLINE withRWS #-}
 
 -- ---------------------------------------------------------------------------
 -- | A monad transformer adding reading an environment of type @r@,
@@ -137,6 +143,7 @@ evalRWST :: (Monad m)
 evalRWST m r s = do
     ~(a, _, w) <- runRWST m r s
     return (a, w)
+{-# INLINE evalRWST #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final state and output, discarding the final value.
@@ -148,12 +155,14 @@ execRWST :: (Monad m)
 execRWST m r s = do
     ~(_, s', w) <- runRWST m r s
     return (s', w)
+{-# INLINE execRWST #-}
 
 -- | Map the inner computation using the given function.
 --
 -- * @'runRWST' ('mapRWST' f m) r s = f ('runRWST' m r s)@
 mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
 mapRWST f m = RWST $ \ r s -> f (runRWST m r s)
+{-# INLINE mapRWST #-}
 
 -- | @'withRWST' f m@ executes action @m@ with an initial environment
 -- and state modified by applying @f@.
@@ -161,51 +170,66 @@ mapRWST f m = RWST $ \ r s -> f (runRWST m r s)
 -- * @'runRWST' ('withRWST' f m) r s = 'uncurry' ('runRWST' m) (f r s)@
 withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
 withRWST f m = RWST $ \ r s -> uncurry (runRWST m) (f r s)
+{-# INLINE withRWST #-}
 
 instance (Functor m) => Functor (RWST r w s m) where
     fmap f m = RWST $ \ r s ->
         fmap (\ ~(a, s', w) -> (f a, s', w)) $ runRWST m r s
+    {-# INLINE fmap #-}
 
 instance (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) where
     pure a = RWST $ \ _ s -> return (a, s, mempty)
+    {-# INLINE pure #-}
     RWST mf <*> RWST mx  = RWST $ \ r s -> do
         ~(f, s', w)  <- mf r s
         ~(x, s'',w') <- mx r s'
         return (f x, s'', w `mappend` w')
+    {-# INLINE (<*>) #-}
 
 instance (Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) where
     empty = RWST $ \ _ _ -> mzero
+    {-# INLINE empty #-}
     RWST m <|> RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (RWST r w s m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = RWST $ \ _ s -> return (a, s, mempty)
+    {-# INLINE return #-}
 #endif
     m >>= k  = RWST $ \ r s -> do
         ~(a, s', w)  <- runRWST m r s
         ~(b, s'',w') <- runRWST (k a) r s'
         return (b, s'', w `mappend` w')
+    {-# INLINE (>>=) #-}
     fail msg = RWST $ \ _ _ -> fail msg
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monoid w, Fail.MonadFail m) => Fail.MonadFail (RWST r w s m) where
     fail msg = RWST $ \ _ _ -> Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance (Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) where
     mzero = RWST $ \ _ _ -> mzero
+    {-# INLINE mzero #-}
     RWST m `mplus` RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    {-# INLINE mplus #-}
 
 instance (Monoid w, MonadFix m) => MonadFix (RWST r w s m) where
     mfix f = RWST $ \ r s -> mfix $ \ ~(a, _, _) -> runRWST (f a) r s
+    {-# INLINE mfix #-}
 
 instance (Monoid w) => MonadTrans (RWST r w s) where
     lift m = RWST $ \ _ s -> do
         a <- m
         return (a, s, mempty)
+    {-# INLINE lift #-}
 
 instance (Monoid w, MonadIO m) => MonadIO (RWST r w s m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 -- ---------------------------------------------------------------------------
 -- Reader operations
@@ -213,22 +237,26 @@ instance (Monoid w, MonadIO m) => MonadIO (RWST r w s m) where
 -- | Constructor for computations in the reader monad (equivalent to 'asks').
 reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
 reader = asks
+{-# INLINE reader #-}
 
 -- | Fetch the value of the environment.
 ask :: (Monoid w, Monad m) => RWST r w s m r
 ask = RWST $ \ r s -> return (r, s, mempty)
+{-# INLINE ask #-}
 
 -- | Execute a computation in a modified environment
 --
 -- * @'runRWST' ('local' f m) r s = 'runRWST' m (f r) s@
 local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
 local f m = RWST $ \ r s -> runRWST m (f r) s
+{-# INLINE local #-}
 
 -- | Retrieve a function of the current environment.
 --
 -- * @'asks' f = 'liftM' f 'ask'@
 asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
 asks f = RWST $ \ r s -> return (f r, s, mempty)
+{-# INLINE asks #-}
 
 -- ---------------------------------------------------------------------------
 -- Writer operations
@@ -236,10 +264,12 @@ asks f = RWST $ \ r s -> return (f r, s, mempty)
 -- | Construct a writer computation from a (result, output) pair.
 writer :: (Monad m) => (a, w) -> RWST r w s m a
 writer (a, w) = RWST $ \ _ s -> return (a, s, w)
+{-# INLINE writer #-}
 
 -- | @'tell' w@ is an action that produces the output @w@.
 tell :: (Monad m) => w -> RWST r w s m ()
 tell w = RWST $ \ _ s -> return ((),s,w)
+{-# INLINE tell #-}
 
 -- | @'listen' m@ is an action that executes the action @m@ and adds its
 -- output to the value of the computation.
@@ -249,6 +279,7 @@ listen :: (Monad m) => RWST r w s m a -> RWST r w s m (a, w)
 listen m = RWST $ \ r s -> do
     ~(a, s', w) <- runRWST m r s
     return ((a, w), s', w)
+{-# INLINE listen #-}
 
 -- | @'listens' f m@ is an action that executes the action @m@ and adds
 -- the result of applying @f@ to the output to the value of the computation.
@@ -260,6 +291,7 @@ listens :: (Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
 listens f m = RWST $ \ r s -> do
     ~(a, s', w) <- runRWST m r s
     return ((a, f w), s', w)
+{-# INLINE listens #-}
 
 -- | @'pass' m@ is an action that executes the action @m@, which returns
 -- a value and a function, and returns the value, applying the function
@@ -270,6 +302,7 @@ pass :: (Monad m) => RWST r w s m (a, w -> w) -> RWST r w s m a
 pass m = RWST $ \ r s -> do
     ~((a, f), s', w) <- runRWST m r s
     return (a, s', f w)
+{-# INLINE pass #-}
 
 -- | @'censor' f m@ is an action that executes the action @m@ and
 -- applies the function @f@ to its output, leaving the return value
@@ -282,6 +315,7 @@ censor :: (Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
 censor f m = RWST $ \ r s -> do
     ~(a, s', w) <- runRWST m r s
     return (a, s', f w)
+{-# INLINE censor #-}
 
 -- ---------------------------------------------------------------------------
 -- State operations
@@ -289,14 +323,17 @@ censor f m = RWST $ \ r s -> do
 -- | Construct a state monad computation from a state transformer function.
 state :: (Monoid w, Monad m) => (s -> (a,s)) -> RWST r w s m a
 state f = RWST $ \ _ s -> let (a,s') = f s  in  return (a, s', mempty)
+{-# INLINE state #-}
 
 -- | Fetch the current value of the state within the monad.
 get :: (Monoid w, Monad m) => RWST r w s m s
 get = RWST $ \ _ s -> return (s, s, mempty)
+{-# INLINE get #-}
 
 -- | @'put' s@ sets the state within the monad to @s@.
 put :: (Monoid w, Monad m) => s -> RWST r w s m ()
 put s = RWST $ \ _ _ -> return ((), s, mempty)
+{-# INLINE put #-}
 
 -- | @'modify' f@ is an action that updates the state to the result of
 -- applying @f@ to the current state.
@@ -304,6 +341,7 @@ put s = RWST $ \ _ _ -> return ((), s, mempty)
 -- * @'modify' f = 'get' >>= ('put' . f)@
 modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
 modify f = RWST $ \ _ s -> return ((), f s, mempty)
+{-# INLINE modify #-}
 
 -- | Get a specific component of the state, using a projection function
 -- supplied.
@@ -311,6 +349,7 @@ modify f = RWST $ \ _ s -> return ((), f s, mempty)
 -- * @'gets' f = 'liftM' f 'get'@
 gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
 gets f = RWST $ \ _ s -> return (f s, s, mempty)
+{-# INLINE gets #-}
 
 -- | Uniform lifting of a @callCC@ operation to the new monad.
 -- This version rolls back to the original state on entering the
@@ -320,6 +359,7 @@ liftCallCC :: (Monoid w) =>
 liftCallCC callCC f = RWST $ \ r s ->
     callCC $ \ c ->
     runRWST (f (\ a -> RWST $ \ _ _ -> c (a, s, mempty))) r s
+{-# INLINE liftCallCC #-}
 
 -- | In-situ lifting of a @callCC@ operation to the new monad.
 -- This version uses the current state on entering the continuation.
@@ -328,8 +368,10 @@ liftCallCC' :: (Monoid w) =>
 liftCallCC' callCC f = RWST $ \ r s ->
     callCC $ \ c ->
     runRWST (f (\ a -> RWST $ \ _ s' -> c (a, s', mempty))) r s
+{-# INLINE liftCallCC' #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,s,w) -> Catch e (RWST r w s m) a
 liftCatch catchE m h =
     RWST $ \ r s -> runRWST m r s `catchE` \ e -> runRWST (h e) r s
+{-# INLINE liftCatch #-}
index b9c86ad..32f2af5 100644 (file)
@@ -81,11 +81,13 @@ type RWS r w s = RWST r w s Identity
 -- (The inverse of 'runRWS'.)
 rws :: (r -> s -> (a, s, w)) -> RWS r w s a
 rws f = RWST (\ r s -> Identity (f r s))
+{-# INLINE rws #-}
 
 -- | Unwrap an RWS computation as a function.
 -- (The inverse of 'rws'.)
 runRWS :: RWS r w s a -> r -> s -> (a, s, w)
 runRWS m r s = runIdentity (runRWST m r s)
+{-# INLINE runRWS #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final value and output, discarding the final state.
@@ -96,6 +98,7 @@ evalRWS :: RWS r w s a  -- ^RWS computation to execute
 evalRWS m r s = let
     (a, _, w) = runRWS m r s
     in (a, w)
+{-# INLINE evalRWS #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final state and output, discarding the final value.
@@ -106,6 +109,7 @@ execRWS :: RWS r w s a  -- ^RWS computation to execute
 execRWS m r s = let
     (_, s', w) = runRWS m r s
     in (s', w)
+{-# INLINE execRWS #-}
 
 -- | Map the return value, final state and output of a computation using
 -- the given function.
@@ -113,6 +117,7 @@ execRWS m r s = let
 -- * @'runRWS' ('mapRWS' f m) r s = f ('runRWS' m r s)@
 mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b
 mapRWS f = mapRWST (Identity . f . runIdentity)
+{-# INLINE mapRWS #-}
 
 -- | @'withRWS' f m@ executes action @m@ with an initial environment
 -- and state modified by applying @f@.
@@ -120,6 +125,7 @@ mapRWS f = mapRWST (Identity . f . runIdentity)
 -- * @'runRWS' ('withRWS' f m) r s = 'uncurry' ('runRWS' m) (f r s)@
 withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a
 withRWS = withRWST
+{-# INLINE withRWS #-}
 
 -- ---------------------------------------------------------------------------
 -- | A monad transformer adding reading an environment of type @r@,
@@ -137,6 +143,7 @@ evalRWST :: (Monad m)
 evalRWST m r s = do
     (a, _, w) <- runRWST m r s
     return (a, w)
+{-# INLINE evalRWST #-}
 
 -- | Evaluate a computation with the given initial state and environment,
 -- returning the final state and output, discarding the final value.
@@ -148,12 +155,14 @@ execRWST :: (Monad m)
 execRWST m r s = do
     (_, s', w) <- runRWST m r s
     return (s', w)
+{-# INLINE execRWST #-}
 
 -- | Map the inner computation using the given function.
 --
 -- * @'runRWST' ('mapRWST' f m) r s = f ('runRWST' m r s)@
 mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
 mapRWST f m = RWST $ \ r s -> f (runRWST m r s)
+{-# INLINE mapRWST #-}
 
 -- | @'withRWST' f m@ executes action @m@ with an initial environment
 -- and state modified by applying @f@.
@@ -161,51 +170,66 @@ mapRWST f m = RWST $ \ r s -> f (runRWST m r s)
 -- * @'runRWST' ('withRWST' f m) r s = 'uncurry' ('runRWST' m) (f r s)@
 withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
 withRWST f m = RWST $ \ r s -> uncurry (runRWST m) (f r s)
+{-# INLINE withRWST #-}
 
 instance (Functor m) => Functor (RWST r w s m) where
     fmap f m = RWST $ \ r s ->
         fmap (\ (a, s', w) -> (f a, s', w)) $ runRWST m r s
+    {-# INLINE fmap #-}
 
 instance (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) where
     pure a = RWST $ \ _ s -> return (a, s, mempty)
+    {-# INLINE pure #-}
     RWST mf <*> RWST mx = RWST $ \ r s -> do
         (f, s', w)  <- mf r s
         (x, s'',w') <- mx r s'
         return (f x, s'', w `mappend` w')
+    {-# INLINE (<*>) #-}
 
 instance (Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) where
     empty = RWST $ \ _ _ -> mzero
+    {-# INLINE empty #-}
     RWST m <|> RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (RWST r w s m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = RWST $ \ _ s -> return (a, s, mempty)
+    {-# INLINE return #-}
 #endif
     m >>= k  = RWST $ \ r s -> do
         (a, s', w)  <- runRWST m r s
         (b, s'',w') <- runRWST (k a) r s'
         return (b, s'', w `mappend` w')
+    {-# INLINE (>>=) #-}
     fail msg = RWST $ \ _ _ -> fail msg
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monoid w, Fail.MonadFail m) => Fail.MonadFail (RWST r w s m) where
     fail msg = RWST $ \ _ _ -> Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance (Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) where
     mzero = RWST $ \ _ _ -> mzero
+    {-# INLINE mzero #-}
     RWST m `mplus` RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    {-# INLINE mplus #-}
 
 instance (Monoid w, MonadFix m) => MonadFix (RWST r w s m) where
     mfix f = RWST $ \ r s -> mfix $ \ ~(a, _, _) -> runRWST (f a) r s
+    {-# INLINE mfix #-}
 
 instance (Monoid w) => MonadTrans (RWST r w s) where
     lift m = RWST $ \ _ s -> do
         a <- m
         return (a, s, mempty)
+    {-# INLINE lift #-}
 
 instance (Monoid w, MonadIO m) => MonadIO (RWST r w s m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 -- ---------------------------------------------------------------------------
 -- Reader operations
@@ -213,22 +237,26 @@ instance (Monoid w, MonadIO m) => MonadIO (RWST r w s m) where
 -- | Constructor for computations in the reader monad (equivalent to 'asks').
 reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
 reader = asks
+{-# INLINE reader #-}
 
 -- | Fetch the value of the environment.
 ask :: (Monoid w, Monad m) => RWST r w s m r
 ask = RWST $ \ r s -> return (r, s, mempty)
+{-# INLINE ask #-}
 
 -- | Execute a computation in a modified environment
 --
 -- * @'runRWST' ('local' f m) r s = 'runRWST' m (f r) s@
 local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
 local f m = RWST $ \ r s -> runRWST m (f r) s
+{-# INLINE local #-}
 
 -- | Retrieve a function of the current environment.
 --
 -- * @'asks' f = 'liftM' f 'ask'@
 asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
 asks f = RWST $ \ r s -> return (f r, s, mempty)
+{-# INLINE asks #-}
 
 -- ---------------------------------------------------------------------------
 -- Writer operations
@@ -236,10 +264,12 @@ asks f = RWST $ \ r s -> return (f r, s, mempty)
 -- | Construct a writer computation from a (result, output) pair.
 writer :: (Monad m) => (a, w) -> RWST r w s m a
 writer (a, w) = RWST $ \ _ s -> return (a, s, w)
+{-# INLINE writer #-}
 
 -- | @'tell' w@ is an action that produces the output @w@.
 tell :: (Monad m) => w -> RWST r w s m ()
 tell w = RWST $ \ _ s -> return ((),s,w)
+{-# INLINE tell #-}
 
 -- | @'listen' m@ is an action that executes the action @m@ and adds its
 -- output to the value of the computation.
@@ -249,6 +279,7 @@ listen :: (Monad m) => RWST r w s m a -> RWST r w s m (a, w)
 listen m = RWST $ \ r s -> do
     (a, s', w) <- runRWST m r s
     return ((a, w), s', w)
+{-# INLINE listen #-}
 
 -- | @'listens' f m@ is an action that executes the action @m@ and adds
 -- the result of applying @f@ to the output to the value of the computation.
@@ -260,6 +291,7 @@ listens :: (Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
 listens f m = RWST $ \ r s -> do
     (a, s', w) <- runRWST m r s
     return ((a, f w), s', w)
+{-# INLINE listens #-}
 
 -- | @'pass' m@ is an action that executes the action @m@, which returns
 -- a value and a function, and returns the value, applying the function
@@ -270,6 +302,7 @@ pass :: (Monad m) => RWST r w s m (a, w -> w) -> RWST r w s m a
 pass m = RWST $ \ r s -> do
     ((a, f), s', w) <- runRWST m r s
     return (a, s', f w)
+{-# INLINE pass #-}
 
 -- | @'censor' f m@ is an action that executes the action @m@ and
 -- applies the function @f@ to its output, leaving the return value
@@ -282,6 +315,7 @@ censor :: (Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
 censor f m = RWST $ \ r s -> do
     (a, s', w) <- runRWST m r s
     return (a, s', f w)
+{-# INLINE censor #-}
 
 -- ---------------------------------------------------------------------------
 -- State operations
@@ -289,14 +323,17 @@ censor f m = RWST $ \ r s -> do
 -- | Construct a state monad computation from a state transformer function.
 state :: (Monoid w, Monad m) => (s -> (a,s)) -> RWST r w s m a
 state f = RWST $ \ _ s -> case f s of (a,s') -> return (a, s', mempty)
+{-# INLINE state #-}
 
 -- | Fetch the current value of the state within the monad.
 get :: (Monoid w, Monad m) => RWST r w s m s
 get = RWST $ \ _ s -> return (s, s, mempty)
+{-# INLINE get #-}
 
 -- | @'put' s@ sets the state within the monad to @s@.
 put :: (Monoid w, Monad m) => s -> RWST r w s m ()
 put s = RWST $ \ _ _ -> return ((), s, mempty)
+{-# INLINE put #-}
 
 -- | @'modify' f@ is an action that updates the state to the result of
 -- applying @f@ to the current state.
@@ -304,6 +341,7 @@ put s = RWST $ \ _ _ -> return ((), s, mempty)
 -- * @'modify' f = 'get' >>= ('put' . f)@
 modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
 modify f = RWST $ \ _ s -> return ((), f s, mempty)
+{-# INLINE modify #-}
 
 -- | Get a specific component of the state, using a projection function
 -- supplied.
@@ -311,6 +349,7 @@ modify f = RWST $ \ _ s -> return ((), f s, mempty)
 -- * @'gets' f = 'liftM' f 'get'@
 gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
 gets f = RWST $ \ _ s -> return (f s, s, mempty)
+{-# INLINE gets #-}
 
 -- | Uniform lifting of a @callCC@ operation to the new monad.
 -- This version rolls back to the original state on entering the
@@ -320,6 +359,7 @@ liftCallCC :: (Monoid w) =>
 liftCallCC callCC f = RWST $ \ r s ->
     callCC $ \ c ->
     runRWST (f (\ a -> RWST $ \ _ _ -> c (a, s, mempty))) r s
+{-# INLINE liftCallCC #-}
 
 -- | In-situ lifting of a @callCC@ operation to the new monad.
 -- This version uses the current state on entering the continuation.
@@ -328,8 +368,10 @@ liftCallCC' :: (Monoid w) =>
 liftCallCC' callCC f = RWST $ \ r s ->
     callCC $ \ c ->
     runRWST (f (\ a -> RWST $ \ _ s' -> c (a, s', mempty))) r s
+{-# INLINE liftCallCC' #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,s,w) -> Catch e (RWST r w s m) a
 liftCatch catchE m h =
     RWST $ \ r s -> runRWST m r s `catchE` \ e -> runRWST (h e) r s
+{-# INLINE liftCatch #-}
index 4f9ab02..00b2d09 100644 (file)
@@ -75,20 +75,23 @@ type Reader r = ReaderT r Identity
 -- | Constructor for computations in the reader monad (equivalent to 'asks').
 reader :: (Monad m) => (r -> a) -> ReaderT r m a
 reader f = ReaderT (return . f)
+{-# INLINE reader #-}
 
 -- | Runs a @Reader@ and extracts the final value from it.
 -- (The inverse of 'reader'.)
 runReader
-     :: Reader r a      -- ^ A @Reader@ to run.
+    :: Reader r a       -- ^ A @Reader@ to run.
     -> r                -- ^ An initial environment.
     -> a
 runReader m = runIdentity . runReaderT m
+{-# INLINE runReader #-}
 
 -- | Transform the value returned by a @Reader@.
 --
 -- * @'runReader' ('mapReader' f m) = f . 'runReader' m@
 mapReader :: (a -> b) -> Reader r a -> Reader r b
 mapReader f = mapReaderT (Identity . f . runIdentity)
+{-# INLINE mapReader #-}
 
 -- | Execute a computation in a modified environment
 -- (a specialization of 'withReaderT').
@@ -99,6 +102,7 @@ withReader
     -> Reader r a       -- ^ Computation to run in the modified environment.
     -> Reader r' a
 withReader = withReaderT
+{-# INLINE withReader #-}
 
 -- | The reader monad transformer,
 -- which adds a read-only environment to the given monad.
@@ -112,6 +116,7 @@ newtype ReaderT r m a = ReaderT { runReaderT :: r -> m a }
 -- * @'runReaderT' ('mapReaderT' f m) = f . 'runReaderT' m@
 mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b
 mapReaderT f m = ReaderT $ f . runReaderT m
+{-# INLINE mapReaderT #-}
 
 -- | Execute a computation in a modified environment
 -- (a more general version of 'local').
@@ -122,57 +127,75 @@ withReaderT
     -> ReaderT r m a    -- ^ Computation to run in the modified environment.
     -> ReaderT r' m a
 withReaderT f m = ReaderT $ runReaderT m . f
+{-# INLINE withReaderT #-}
 
 instance (Functor m) => Functor (ReaderT r m) where
     fmap f  = mapReaderT (fmap f)
+    {-# INLINE fmap #-}
 
 instance (Applicative m) => Applicative (ReaderT r m) where
     pure    = liftReaderT . pure
+    {-# INLINE pure #-}
     f <*> v = ReaderT $ \ r -> runReaderT f r <*> runReaderT v r
+    {-# INLINE (<*>) #-}
 
 instance (Alternative m) => Alternative (ReaderT r m) where
     empty   = liftReaderT empty
+    {-# INLINE empty #-}
     m <|> n = ReaderT $ \ r -> runReaderT m r <|> runReaderT n r
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (ReaderT r m) where
 #if !(MIN_VERSION_base(4,8,0))
     return   = lift . return
+    {-# INLINE return #-}
 #endif
     m >>= k  = ReaderT $ \ r -> do
         a <- runReaderT m r
         runReaderT (k a) r
+    {-# INLINE (>>=) #-}
     fail msg = lift (fail msg)
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (ReaderT r m) where
     fail msg = lift (Fail.fail msg)
+    {-# INLINE fail #-}
 #endif
 
 instance (MonadPlus m) => MonadPlus (ReaderT r m) where
     mzero       = lift mzero
+    {-# INLINE mzero #-}
     m `mplus` n = ReaderT $ \ r -> runReaderT m r `mplus` runReaderT n r
+    {-# INLINE mplus #-}
 
 instance (MonadFix m) => MonadFix (ReaderT r m) where
     mfix f = ReaderT $ \ r -> mfix $ \ a -> runReaderT (f a) r
+    {-# INLINE mfix #-}
 
 instance MonadTrans (ReaderT r) where
     lift   = liftReaderT
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (ReaderT r m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (MonadZip m) => MonadZip (ReaderT r m) where
     mzipWith f (ReaderT m) (ReaderT n) = ReaderT $ \ a ->
         mzipWith f (m a) (n a)
+    {-# INLINE mzipWith #-}
 #endif
 
 liftReaderT :: m a -> ReaderT r m a
 liftReaderT m = ReaderT (const m)
+{-# INLINE liftReaderT #-}
 
 -- | Fetch the value of the environment.
 ask :: (Monad m) => ReaderT r m r
 ask = ReaderT return
+{-# INLINE ask #-}
 
 -- | Execute a computation in a modified environment
 -- (a specialization of 'withReaderT').
@@ -183,6 +206,7 @@ local
     -> ReaderT r m a    -- ^ Computation to run in the modified environment.
     -> ReaderT r m a
 local = withReaderT
+{-# INLINE local #-}
 
 -- | Retrieve a function of the current environment.
 --
@@ -191,14 +215,17 @@ asks :: (Monad m)
     => (r -> a)         -- ^ The selector function to apply to the environment.
     -> ReaderT r m a
 asks f = ReaderT (return . f)
+{-# INLINE asks #-}
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: CallCC m a b -> CallCC (ReaderT r m) a b
 liftCallCC callCC f = ReaderT $ \ r ->
     callCC $ \ c ->
     runReaderT (f (ReaderT . const . c)) r
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m a -> Catch e (ReaderT r m) a
 liftCatch f m h =
     ReaderT $ \ r -> f (runReaderT m r) (\ e -> runReaderT (h e) r)
+{-# INLINE liftCatch #-}
index ab4f8ee..a2f84dc 100644 (file)
@@ -99,6 +99,7 @@ state :: (Monad m)
       => (s -> (a, s))  -- ^pure state transformer
       -> StateT s m a   -- ^equivalent state-passing computation
 state f = StateT (return . f)
+{-# INLINE state #-}
 
 -- | Unwrap a state monad computation as a function.
 -- (The inverse of 'state'.)
@@ -106,6 +107,7 @@ runState :: State s a   -- ^state-passing computation to execute
          -> s           -- ^initial state
          -> (a, s)      -- ^return value and final state
 runState m = runIdentity . runStateT m
+{-# INLINE runState #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final value, discarding the final state.
@@ -115,6 +117,7 @@ evalState :: State s a  -- ^state-passing computation to execute
           -> s          -- ^initial value
           -> a          -- ^return value of the state computation
 evalState m s = fst (runState m s)
+{-# INLINE evalState #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final state, discarding the final value.
@@ -124,6 +127,7 @@ execState :: State s a  -- ^state-passing computation to execute
           -> s          -- ^initial value
           -> s          -- ^final state
 execState m s = snd (runState m s)
+{-# INLINE execState #-}
 
 -- | Map both the return value and final state of a computation using
 -- the given function.
@@ -131,6 +135,7 @@ execState m s = snd (runState m s)
 -- * @'runState' ('mapState' f m) = f . 'runState' m@
 mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
 mapState f = mapStateT (Identity . f . runIdentity)
+{-# INLINE mapState #-}
 
 -- | @'withState' f m@ executes action @m@ on a state modified by
 -- applying @f@.
@@ -138,6 +143,7 @@ mapState f = mapStateT (Identity . f . runIdentity)
 -- * @'withState' f m = 'modify' f >> m@
 withState :: (s -> s) -> State s a -> State s a
 withState = withStateT
+{-# INLINE withState #-}
 
 -- ---------------------------------------------------------------------------
 -- | A state transformer monad parameterized by:
@@ -159,6 +165,7 @@ evalStateT :: (Monad m) => StateT s m a -> s -> m a
 evalStateT m s = do
     ~(a, _) <- runStateT m s
     return a
+{-# INLINE evalStateT #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final state, discarding the final value.
@@ -168,6 +175,7 @@ execStateT :: (Monad m) => StateT s m a -> s -> m s
 execStateT m s = do
     ~(_, s') <- runStateT m s
     return s'
+{-# INLINE execStateT #-}
 
 -- | Map both the return value and final state of a computation using
 -- the given function.
@@ -175,6 +183,7 @@ execStateT m s = do
 -- * @'runStateT' ('mapStateT' f m) = f . 'runStateT' m@
 mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
 mapStateT f m = StateT $ f . runStateT m
+{-# INLINE mapStateT #-}
 
 -- | @'withStateT' f m@ executes action @m@ on a state modified by
 -- applying @f@.
@@ -182,13 +191,16 @@ mapStateT f m = StateT $ f . runStateT m
 -- * @'withStateT' f m = 'modify' f >> m@
 withStateT :: (s -> s) -> StateT s m a -> StateT s m a
 withStateT f m = StateT $ runStateT m . f
+{-# INLINE withStateT #-}
 
 instance (Functor m) => Functor (StateT s m) where
     fmap f m = StateT $ \ s ->
         fmap (\ ~(a, s') -> (f a, s')) $ runStateT m s
+    {-# INLINE fmap #-}
 
 instance (Functor m, Monad m) => Applicative (StateT s m) where
     pure a = StateT $ \ s -> return (a, s)
+    {-# INLINE pure #-}
     StateT mf <*> StateT mx = StateT $ \ s -> do
         ~(f, s') <- mf s
         ~(x, s'') <- mx s'
@@ -197,44 +209,57 @@ instance (Functor m, Monad m) => Applicative (StateT s m) where
 
 instance (Functor m, MonadPlus m) => Alternative (StateT s m) where
     empty = StateT $ \ _ -> mzero
+    {-# INLINE empty #-}
     StateT m <|> StateT n = StateT $ \ s -> m s `mplus` n s
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (StateT s m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = StateT $ \ s -> return (a, s)
+    {-# INLINE return #-}
 #endif
     m >>= k  = StateT $ \ s -> do
         ~(a, s') <- runStateT m s
         runStateT (k a) s'
+    {-# INLINE (>>=) #-}
     fail str = StateT $ \ _ -> fail str
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (StateT s m) where
     fail str = StateT $ \ _ -> Fail.fail str
+    {-# INLINE fail #-}
 #endif
 
 instance (MonadPlus m) => MonadPlus (StateT s m) where
     mzero       = StateT $ \ _ -> mzero
+    {-# INLINE mzero #-}
     StateT m `mplus` StateT n = StateT $ \ s -> m s `mplus` n s
+    {-# INLINE mplus #-}
 
 instance (MonadFix m) => MonadFix (StateT s m) where
     mfix f = StateT $ \ s -> mfix $ \ ~(a, _) -> runStateT (f a) s
+    {-# INLINE mfix #-}
 
 instance MonadTrans (StateT s) where
     lift m = StateT $ \ s -> do
         a <- m
         return (a, s)
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (StateT s m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 -- | Fetch the current value of the state within the monad.
 get :: (Monad m) => StateT s m s
 get = state $ \ s -> (s, s)
+{-# INLINE get #-}
 
 -- | @'put' s@ sets the state within the monad to @s@.
 put :: (Monad m) => s -> StateT s m ()
 put s = state $ \ _ -> ((), s)
+{-# INLINE put #-}
 
 -- | @'modify' f@ is an action that updates the state to the result of
 -- applying @f@ to the current state.
@@ -242,6 +267,7 @@ put s = state $ \ _ -> ((), s)
 -- * @'modify' f = 'get' >>= ('put' . f)@
 modify :: (Monad m) => (s -> s) -> StateT s m ()
 modify f = state $ \ s -> ((), f s)
+{-# INLINE modify #-}
 
 -- | A variant of 'modify' in which the computation is strict in the
 -- new state.
@@ -251,6 +277,7 @@ modify' :: (Monad m) => (s -> s) -> StateT s m ()
 modify' f = do
     s <- get
     put $! f s
+{-# INLINE modify' #-}
 
 -- | Get a specific component of the state, using a projection function
 -- supplied.
@@ -258,6 +285,7 @@ modify' f = do
 -- * @'gets' f = 'liftM' f 'get'@
 gets :: (Monad m) => (s -> a) -> StateT s m a
 gets f = state $ \ s -> (f s, s)
+{-# INLINE gets #-}
 
 -- | Uniform lifting of a @callCC@ operation to the new monad.
 -- This version rolls back to the original state on entering the
@@ -266,6 +294,7 @@ liftCallCC :: CallCC m (a,s) (b,s) -> CallCC (StateT s m) a b
 liftCallCC callCC f = StateT $ \ s ->
     callCC $ \ c ->
     runStateT (f (\ a -> StateT $ \ _ -> c (a, s))) s
+{-# INLINE liftCallCC #-}
 
 -- | In-situ lifting of a @callCC@ operation to the new monad.
 -- This version uses the current state on entering the continuation.
@@ -274,23 +303,27 @@ liftCallCC' :: CallCC m (a,s) (b,s) -> CallCC (StateT s m) a b
 liftCallCC' callCC f = StateT $ \ s ->
     callCC $ \ c ->
     runStateT (f (\ a -> StateT $ \ s' -> c (a, s'))) s
+{-# INLINE liftCallCC' #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,s) -> Catch e (StateT s m) a
 liftCatch catchE m h =
     StateT $ \ s -> runStateT m s `catchE` \ e -> runStateT (h e) s
+{-# INLINE liftCatch #-}
 
 -- | Lift a @listen@ operation to the new monad.
 liftListen :: (Monad m) => Listen w m (a,s) -> Listen w (StateT s m) a
 liftListen listen m = StateT $ \ s -> do
     ~((a, s'), w) <- listen (runStateT m s)
     return ((a, w), s')
+{-# INLINE liftListen #-}
 
 -- | Lift a @pass@ operation to the new monad.
 liftPass :: (Monad m) => Pass w m (a,s) -> Pass w (StateT s m) a
 liftPass pass m = StateT $ \ s -> pass $ do
     ~((a, f), s') <- runStateT m s
     return ((a, s'), f)
+{-# INLINE liftPass #-}
 
 {- $examples
 
index 5845ad5..df5008c 100644 (file)
@@ -96,6 +96,7 @@ state :: (Monad m)
       => (s -> (a, s))  -- ^pure state transformer
       -> StateT s m a   -- ^equivalent state-passing computation
 state f = StateT (return . f)
+{-# INLINE state #-}
 
 -- | Unwrap a state monad computation as a function.
 -- (The inverse of 'state'.)
@@ -103,6 +104,7 @@ runState :: State s a   -- ^state-passing computation to execute
          -> s           -- ^initial state
          -> (a, s)      -- ^return value and final state
 runState m = runIdentity . runStateT m
+{-# INLINE runState #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final value, discarding the final state.
@@ -112,6 +114,7 @@ evalState :: State s a  -- ^state-passing computation to execute
           -> s          -- ^initial value
           -> a          -- ^return value of the state computation
 evalState m s = fst (runState m s)
+{-# INLINE evalState #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final state, discarding the final value.
@@ -121,6 +124,7 @@ execState :: State s a  -- ^state-passing computation to execute
           -> s          -- ^initial value
           -> s          -- ^final state
 execState m s = snd (runState m s)
+{-# INLINE execState #-}
 
 -- | Map both the return value and final state of a computation using
 -- the given function.
@@ -128,6 +132,7 @@ execState m s = snd (runState m s)
 -- * @'runState' ('mapState' f m) = f . 'runState' m@
 mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
 mapState f = mapStateT (Identity . f . runIdentity)
+{-# INLINE mapState #-}
 
 -- | @'withState' f m@ executes action @m@ on a state modified by
 -- applying @f@.
@@ -135,6 +140,7 @@ mapState f = mapStateT (Identity . f . runIdentity)
 -- * @'withState' f m = 'modify' f >> m@
 withState :: (s -> s) -> State s a -> State s a
 withState = withStateT
+{-# INLINE withState #-}
 
 -- ---------------------------------------------------------------------------
 -- | A state transformer monad parameterized by:
@@ -156,6 +162,7 @@ evalStateT :: (Monad m) => StateT s m a -> s -> m a
 evalStateT m s = do
     (a, _) <- runStateT m s
     return a
+{-# INLINE evalStateT #-}
 
 -- | Evaluate a state computation with the given initial state
 -- and return the final state, discarding the final value.
@@ -165,6 +172,7 @@ execStateT :: (Monad m) => StateT s m a -> s -> m s
 execStateT m s = do
     (_, s') <- runStateT m s
     return s'
+{-# INLINE execStateT #-}
 
 -- | Map both the return value and final state of a computation using
 -- the given function.
@@ -172,6 +180,7 @@ execStateT m s = do
 -- * @'runStateT' ('mapStateT' f m) = f . 'runStateT' m@
 mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
 mapStateT f m = StateT $ f . runStateT m
+{-# INLINE mapStateT #-}
 
 -- | @'withStateT' f m@ executes action @m@ on a state modified by
 -- applying @f@.
@@ -179,13 +188,16 @@ mapStateT f m = StateT $ f . runStateT m
 -- * @'withStateT' f m = 'modify' f >> m@
 withStateT :: (s -> s) -> StateT s m a -> StateT s m a
 withStateT f m = StateT $ runStateT m . f
+{-# INLINE withStateT #-}
 
 instance (Functor m) => Functor (StateT s m) where
     fmap f m = StateT $ \ s ->
         fmap (\ (a, s') -> (f a, s')) $ runStateT m s
+    {-# INLINE fmap #-}
 
 instance (Functor m, Monad m) => Applicative (StateT s m) where
     pure a = StateT $ \ s -> return (a, s)
+    {-# INLINE pure #-}
     StateT mf <*> StateT mx = StateT $ \ s -> do
         (f, s') <- mf s
         (x, s'') <- mx s'
@@ -194,44 +206,57 @@ instance (Functor m, Monad m) => Applicative (StateT s m) where
 
 instance (Functor m, MonadPlus m) => Alternative (StateT s m) where
     empty = StateT $ \ _ -> mzero
+    {-# INLINE empty #-}
     StateT m <|> StateT n = StateT $ \ s -> m s `mplus` n s
+    {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (StateT s m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = StateT $ \ s -> return (a, s)
+    {-# INLINE return #-}
 #endif
     m >>= k  = StateT $ \ s -> do
         (a, s') <- runStateT m s
         runStateT (k a) s'
+    {-# INLINE (>>=) #-}
     fail str = StateT $ \ _ -> fail str
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Fail.MonadFail m) => Fail.MonadFail (StateT s m) where
     fail str = StateT $ \ _ -> Fail.fail str
+    {-# INLINE fail #-}
 #endif
 
 instance (MonadPlus m) => MonadPlus (StateT s m) where
     mzero       = StateT $ \ _ -> mzero
-    m `mplus` n = StateT $ \ s -> runStateT m s `mplus` runStateT n s
+    {-# INLINE mzero #-}
+    StateT m `mplus` StateT n = StateT $ \ s -> m s `mplus` n s
+    {-# INLINE mplus #-}
 
 instance (MonadFix m) => MonadFix (StateT s m) where
     mfix f = StateT $ \ s -> mfix $ \ ~(a, _) -> runStateT (f a) s
+    {-# INLINE mfix #-}
 
 instance MonadTrans (StateT s) where
     lift m = StateT $ \ s -> do
         a <- m
         return (a, s)
+    {-# INLINE lift #-}
 
 instance (MonadIO m) => MonadIO (StateT s m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 -- | Fetch the current value of the state within the monad.
 get :: (Monad m) => StateT s m s
 get = state $ \ s -> (s, s)
+{-# INLINE get #-}
 
 -- | @'put' s@ sets the state within the monad to @s@.
 put :: (Monad m) => s -> StateT s m ()
 put s = state $ \ _ -> ((), s)
+{-# INLINE put #-}
 
 -- | @'modify' f@ is an action that updates the state to the result of
 -- applying @f@ to the current state.
@@ -239,6 +264,7 @@ put s = state $ \ _ -> ((), s)
 -- * @'modify' f = 'get' >>= ('put' . f)@
 modify :: (Monad m) => (s -> s) -> StateT s m ()
 modify f = state $ \ s -> ((), f s)
+{-# INLINE modify #-}
 
 -- | A variant of 'modify' in which the computation is strict in the
 -- new state.
@@ -248,6 +274,7 @@ modify' :: (Monad m) => (s -> s) -> StateT s m ()
 modify' f = do
     s <- get
     put $! f s
+{-# INLINE modify' #-}
 
 -- | Get a specific component of the state, using a projection function
 -- supplied.
@@ -255,6 +282,7 @@ modify' f = do
 -- * @'gets' f = 'liftM' f 'get'@
 gets :: (Monad m) => (s -> a) -> StateT s m a
 gets f = state $ \ s -> (f s, s)
+{-# INLINE gets #-}
 
 -- | Uniform lifting of a @callCC@ operation to the new monad.
 -- This version rolls back to the original state on entering the
@@ -263,6 +291,7 @@ liftCallCC :: CallCC m (a,s) (b,s) -> CallCC (StateT s m) a b
 liftCallCC callCC f = StateT $ \ s ->
     callCC $ \ c ->
     runStateT (f (\ a -> StateT $ \ _ -> c (a, s))) s
+{-# INLINE liftCallCC #-}
 
 -- | In-situ lifting of a @callCC@ operation to the new monad.
 -- This version uses the current state on entering the continuation.
@@ -271,23 +300,27 @@ liftCallCC' :: CallCC m (a,s) (b,s) -> CallCC (StateT s m) a b
 liftCallCC' callCC f = StateT $ \ s ->
     callCC $ \ c ->
     runStateT (f (\ a -> StateT $ \ s' -> c (a, s'))) s
+{-# INLINE liftCallCC' #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,s) -> Catch e (StateT s m) a
 liftCatch catchE m h =
     StateT $ \ s -> runStateT m s `catchE` \ e -> runStateT (h e) s
+{-# INLINE liftCatch #-}
 
 -- | Lift a @listen@ operation to the new monad.
 liftListen :: (Monad m) => Listen w m (a,s) -> Listen w (StateT s m) a
 liftListen listen m = StateT $ \ s -> do
     ((a, s'), w) <- listen (runStateT m s)
     return ((a, w), s')
+{-# INLINE liftListen #-}
 
 -- | Lift a @pass@ operation to the new monad.
 liftPass :: (Monad m) => Pass w m (a,s) -> Pass w (StateT s m) a
 liftPass pass m = StateT $ \ s -> pass $ do
     ((a, f), s') <- runStateT m s
     return ((a, s'), f)
+{-# INLINE liftPass #-}
 
 {- $examples
 
index fd648e8..7af38dc 100644 (file)
@@ -79,17 +79,20 @@ type Writer w = WriterT w Identity
 -- (The inverse of 'runWriter'.)
 writer :: (Monad m) => (a, w) -> WriterT w m a
 writer = WriterT . return
+{-# INLINE writer #-}
 
 -- | Unwrap a writer computation as a (result, output) pair.
 -- (The inverse of 'writer'.)
 runWriter :: Writer w a -> (a, w)
 runWriter = runIdentity . runWriterT
+{-# INLINE runWriter #-}
 
 -- | Extract the output from a writer computation.
 --
 -- * @'execWriter' m = 'snd' ('runWriter' m)@
 execWriter :: Writer w a -> w
 execWriter m = snd (runWriter m)
+{-# INLINE execWriter #-}
 
 -- | Map both the return value and output of a computation using
 -- the given function.
@@ -97,6 +100,7 @@ execWriter m = snd (runWriter m)
 -- * @'runWriter' ('mapWriter' f m) = f ('runWriter' m)@
 mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
 mapWriter f = mapWriterT (Identity . f . runIdentity)
+{-# INLINE mapWriter #-}
 
 -- ---------------------------------------------------------------------------
 -- | A writer monad parameterized by:
@@ -111,10 +115,12 @@ newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }
 
 instance (Eq w, Eq1 m) => Eq1 (WriterT w m) where
     liftEq eq (WriterT m1) (WriterT m2) = liftEq (liftEq2 eq (==)) m1 m2
+    {-# INLINE liftEq #-}
 
 instance (Ord w, Ord1 m) => Ord1 (WriterT w m) where
     liftCompare comp (WriterT m1) (WriterT m2) =
         liftCompare (liftCompare2 comp compare) m1 m2
+    {-# INLINE liftCompare #-}
 
 instance (Read w, Read1 m) => Read1 (WriterT w m) where
     liftReadsPrec rp rl = readsData $
@@ -144,6 +150,7 @@ execWriterT :: (Monad m) => WriterT w m a -> m w
 execWriterT m = do
     ~(_, w) <- runWriterT m
     return w
+{-# INLINE execWriterT #-}
 
 -- | Map both the return value and output of a computation using
 -- the given function.
@@ -151,65 +158,84 @@ execWriterT m = do
 -- * @'runWriterT' ('mapWriterT' f m) = f ('runWriterT' m)@
 mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
 mapWriterT f m = WriterT $ f (runWriterT m)
+{-# INLINE mapWriterT #-}
 
 instance (Functor m) => Functor (WriterT w m) where
     fmap f = mapWriterT $ fmap $ \ ~(a, w) -> (f a, w)
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (WriterT w f) where
     foldMap f = foldMap (f . fst) . runWriterT
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (WriterT w f) where
     traverse f = fmap WriterT . traverse f' . runWriterT where
        f' (a, b) = fmap (\ c -> (c, b)) (f a)
+    {-# INLINE traverse #-}
 
 instance (Monoid w, Applicative m) => Applicative (WriterT w m) where
     pure a  = WriterT $ pure (a, mempty)
+    {-# INLINE pure #-}
     f <*> v = WriterT $ liftA2 k (runWriterT f) (runWriterT v)
       where k ~(a, w) ~(b, w') = (a b, w `mappend` w')
+    {-# INLINE (<*>) #-}
 
 instance (Monoid w, Alternative m) => Alternative (WriterT w m) where
     empty   = WriterT empty
+    {-# INLINE empty #-}
     m <|> n = WriterT $ runWriterT m <|> runWriterT n
+    {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (WriterT w m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = writer (a, mempty)
+    {-# INLINE return #-}
 #endif
     m >>= k  = WriterT $ do
         ~(a, w)  <- runWriterT m
         ~(b, w') <- runWriterT (k a)
         return (b, w `mappend` w')
+    {-# INLINE (>>=) #-}
     fail msg = WriterT $ fail msg
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monoid w, Fail.MonadFail m) => Fail.MonadFail (WriterT w m) where
     fail msg = WriterT $ Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) where
     mzero       = WriterT mzero
+    {-# INLINE mzero #-}
     m `mplus` n = WriterT $ runWriterT m `mplus` runWriterT n
+    {-# INLINE mplus #-}
 
 instance (Monoid w, MonadFix m) => MonadFix (WriterT w m) where
     mfix m = WriterT $ mfix $ \ ~(a, _) -> runWriterT (m a)
+    {-# INLINE mfix #-}
 
 instance (Monoid w) => MonadTrans (WriterT w) where
     lift m = WriterT $ do
         a <- m
         return (a, mempty)
+    {-# INLINE lift #-}
 
 instance (Monoid w, MonadIO m) => MonadIO (WriterT w m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (Monoid w, MonadZip m) => MonadZip (WriterT w m) where
     mzipWith f (WriterT x) (WriterT y) = WriterT $
         mzipWith (\ ~(a, w) ~(b, w') -> (f a b, w `mappend` w')) x y
+    {-# INLINE mzipWith #-}
 #endif
 
 -- | @'tell' w@ is an action that produces the output @w@.
 tell :: (Monad m) => w -> WriterT w m ()
 tell w = writer ((), w)
+{-# INLINE tell #-}
 
 -- | @'listen' m@ is an action that executes the action @m@ and adds its
 -- output to the value of the computation.
@@ -219,6 +245,7 @@ listen :: (Monad m) => WriterT w m a -> WriterT w m (a, w)
 listen m = WriterT $ do
     ~(a, w) <- runWriterT m
     return ((a, w), w)
+{-# INLINE listen #-}
 
 -- | @'listens' f m@ is an action that executes the action @m@ and adds
 -- the result of applying @f@ to the output to the value of the computation.
@@ -230,6 +257,7 @@ listens :: (Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
 listens f m = WriterT $ do
     ~(a, w) <- runWriterT m
     return ((a, f w), w)
+{-# INLINE listens #-}
 
 -- | @'pass' m@ is an action that executes the action @m@, which returns
 -- a value and a function, and returns the value, applying the function
@@ -240,6 +268,7 @@ pass :: (Monad m) => WriterT w m (a, w -> w) -> WriterT w m a
 pass m = WriterT $ do
     ~((a, f), w) <- runWriterT m
     return (a, f w)
+{-# INLINE pass #-}
 
 -- | @'censor' f m@ is an action that executes the action @m@ and
 -- applies the function @f@ to its output, leaving the return value
@@ -252,14 +281,17 @@ censor :: (Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a
 censor f m = WriterT $ do
     ~(a, w) <- runWriterT m
     return (a, f w)
+{-# INLINE censor #-}
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: (Monoid w) => CallCC m (a,w) (b,w) -> CallCC (WriterT w m) a b
 liftCallCC callCC f = WriterT $
     callCC $ \ c ->
     runWriterT (f (\ a -> WriterT $ c (a, mempty)))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,w) -> Catch e (WriterT w m) a
 liftCatch catchE m h =
     WriterT $ runWriterT m `catchE` \ e -> runWriterT (h e)
+{-# INLINE liftCatch #-}
index 4055f87..b4bfba6 100644 (file)
@@ -82,17 +82,20 @@ type Writer w = WriterT w Identity
 -- (The inverse of 'runWriter'.)
 writer :: (Monad m) => (a, w) -> WriterT w m a
 writer = WriterT . return
+{-# INLINE writer #-}
 
 -- | Unwrap a writer computation as a (result, output) pair.
 -- (The inverse of 'writer'.)
 runWriter :: Writer w a -> (a, w)
 runWriter = runIdentity . runWriterT
+{-# INLINE runWriter #-}
 
 -- | Extract the output from a writer computation.
 --
 -- * @'execWriter' m = 'snd' ('runWriter' m)@
 execWriter :: Writer w a -> w
 execWriter m = snd (runWriter m)
+{-# INLINE execWriter #-}
 
 -- | Map both the return value and output of a computation using
 -- the given function.
@@ -100,6 +103,7 @@ execWriter m = snd (runWriter m)
 -- * @'runWriter' ('mapWriter' f m) = f ('runWriter' m)@
 mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
 mapWriter f = mapWriterT (Identity . f . runIdentity)
+{-# INLINE mapWriter #-}
 
 -- ---------------------------------------------------------------------------
 -- | A writer monad parameterized by:
@@ -114,10 +118,12 @@ newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }
 
 instance (Eq w, Eq1 m) => Eq1 (WriterT w m) where
     liftEq eq (WriterT m1) (WriterT m2) = liftEq (liftEq2 eq (==)) m1 m2
+    {-# INLINE liftEq #-}
 
 instance (Ord w, Ord1 m) => Ord1 (WriterT w m) where
     liftCompare comp (WriterT m1) (WriterT m2) =
         liftCompare (liftCompare2 comp compare) m1 m2
+    {-# INLINE liftCompare #-}
 
 instance (Read w, Read1 m) => Read1 (WriterT w m) where
     liftReadsPrec rp rl = readsData $
@@ -147,6 +153,7 @@ execWriterT :: (Monad m) => WriterT w m a -> m w
 execWriterT m = do
     (_, w) <- runWriterT m
     return w
+{-# INLINE execWriterT #-}
 
 -- | Map both the return value and output of a computation using
 -- the given function.
@@ -154,65 +161,84 @@ execWriterT m = do
 -- * @'runWriterT' ('mapWriterT' f m) = f ('runWriterT' m)@
 mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
 mapWriterT f m = WriterT $ f (runWriterT m)
+{-# INLINE mapWriterT #-}
 
 instance (Functor m) => Functor (WriterT w m) where
     fmap f = mapWriterT $ fmap $ \ (a, w) -> (f a, w)
+    {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (WriterT w f) where
     foldMap f = foldMap (f . fst) . runWriterT
+    {-# INLINE foldMap #-}
 
 instance (Traversable f) => Traversable (WriterT w f) where
     traverse f = fmap WriterT . traverse f' . runWriterT where
        f' (a, b) = fmap (\ c -> (c, b)) (f a)
+    {-# INLINE traverse #-}
 
 instance (Monoid w, Applicative m) => Applicative (WriterT w m) where
     pure a  = WriterT $ pure (a, mempty)
+    {-# INLINE pure #-}
     f <*> v = WriterT $ liftA2 k (runWriterT f) (runWriterT v)
       where k (a, w) (b, w') = (a b, w `mappend` w')
+    {-# INLINE (<*>) #-}
 
 instance (Monoid w, Alternative m) => Alternative (WriterT w m) where
     empty   = WriterT empty
+    {-# INLINE empty #-}
     m <|> n = WriterT $ runWriterT m <|> runWriterT n
+    {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (WriterT w m) where
 #if !(MIN_VERSION_base(4,8,0))
     return a = writer (a, mempty)
+    {-# INLINE return #-}
 #endif
     m >>= k  = WriterT $ do
         (a, w)  <- runWriterT m
         (b, w') <- runWriterT (k a)
         return (b, w `mappend` w')
+    {-# INLINE (>>=) #-}
     fail msg = WriterT $ fail msg
+    {-# INLINE fail #-}
 
 #if MIN_VERSION_base(4,9,0)
 instance (Monoid w, Fail.MonadFail m) => Fail.MonadFail (WriterT w m) where
     fail msg = WriterT $ Fail.fail msg
+    {-# INLINE fail #-}
 #endif
 
 instance (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) where
     mzero       = WriterT mzero
+    {-# INLINE mzero #-}
     m `mplus` n = WriterT $ runWriterT m `mplus` runWriterT n
+    {-# INLINE mplus #-}
 
 instance (Monoid w, MonadFix m) => MonadFix (WriterT w m) where
     mfix m = WriterT $ mfix $ \ ~(a, _) -> runWriterT (m a)
+    {-# INLINE mfix #-}
 
 instance (Monoid w) => MonadTrans (WriterT w) where
     lift m = WriterT $ do
         a <- m
         return (a, mempty)
+    {-# INLINE lift #-}
 
 instance (Monoid w, MonadIO m) => MonadIO (WriterT w m) where
     liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
 
 #if MIN_VERSION_base(4,4,0)
 instance (Monoid w, MonadZip m) => MonadZip (WriterT w m) where
     mzipWith f (WriterT x) (WriterT y) = WriterT $
         mzipWith (\ (a, w) (b, w') -> (f a b, w `mappend` w')) x y
+    {-# INLINE mzipWith #-}
 #endif
 
 -- | @'tell' w@ is an action that produces the output @w@.
 tell :: (Monad m) => w -> WriterT w m ()
 tell w = writer ((), w)
+{-# INLINE tell #-}
 
 -- | @'listen' m@ is an action that executes the action @m@ and adds its
 -- output to the value of the computation.
@@ -222,6 +248,7 @@ listen :: (Monad m) => WriterT w m a -> WriterT w m (a, w)
 listen m = WriterT $ do
     (a, w) <- runWriterT m
     return ((a, w), w)
+{-# INLINE listen #-}
 
 -- | @'listens' f m@ is an action that executes the action @m@ and adds
 -- the result of applying @f@ to the output to the value of the computation.
@@ -233,6 +260,7 @@ listens :: (Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
 listens f m = WriterT $ do
     (a, w) <- runWriterT m
     return ((a, f w), w)
+{-# INLINE listens #-}
 
 -- | @'pass' m@ is an action that executes the action @m@, which returns
 -- a value and a function, and returns the value, applying the function
@@ -243,6 +271,7 @@ pass :: (Monad m) => WriterT w m (a, w -> w) -> WriterT w m a
 pass m = WriterT $ do
     ((a, f), w) <- runWriterT m
     return (a, f w)
+{-# INLINE pass #-}
 
 -- | @'censor' f m@ is an action that executes the action @m@ and
 -- applies the function @f@ to its output, leaving the return value
@@ -255,14 +284,17 @@ censor :: (Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a
 censor f m = WriterT $ do
     (a, w) <- runWriterT m
     return (a, f w)
+{-# INLINE censor #-}
 
 -- | Lift a @callCC@ operation to the new monad.
 liftCallCC :: (Monoid w) => CallCC m (a,w) (b,w) -> CallCC (WriterT w m) a b
 liftCallCC callCC f = WriterT $
     callCC $ \ c ->
     runWriterT (f (\ a -> WriterT $ c (a, mempty)))
+{-# INLINE liftCallCC #-}
 
 -- | Lift a @catchE@ operation to the new monad.
 liftCatch :: Catch e m (a,w) -> Catch e (WriterT w m) a
 liftCatch catchE m h =
     WriterT $ runWriterT m `catchE` \ e -> runWriterT (h e)
+{-# INLINE liftCatch #-}
index 777d08a..e70f67d 100644 (file)
@@ -53,9 +53,11 @@ instance (Show a) => Show (Constant a b) where
 
 instance Eq2 Constant where
     liftEq2 eq _ (Constant x) (Constant y) = eq x y
+    {-# INLINE liftEq2 #-}
 
 instance Ord2 Constant where
     liftCompare2 comp _ (Constant x) (Constant y) = comp x y
+    {-# INLINE liftCompare2 #-}
 
 instance Read2 Constant where
     liftReadsPrec2 rp _ _ _ = readsData $
@@ -66,32 +68,45 @@ instance Show2 Constant where
 
 instance (Eq a) => Eq1 (Constant a) where
     liftEq = liftEq2 (==)
+    {-# INLINE liftEq #-}
 instance (Ord a) => Ord1 (Constant a) where
     liftCompare = liftCompare2 compare
+    {-# INLINE liftCompare #-}
 instance (Read a) => Read1 (Constant a) where
     liftReadsPrec = liftReadsPrec2 readsPrec readList
+    {-# INLINE liftReadsPrec #-}
 instance (Show a) => Show1 (Constant a) where
     liftShowsPrec = liftShowsPrec2 showsPrec showList
+    {-# INLINE liftShowsPrec #-}
 
 instance Functor (Constant a) where
     fmap _ (Constant x) = Constant x
+    {-# INLINE fmap #-}
 
 instance Foldable (Constant a) where
     foldMap _ (Constant _) = mempty
+    {-# INLINE foldMap #-}
 
 instance Traversable (Constant a) where
     traverse _ (Constant x) = pure (Constant x)
+    {-# INLINE traverse #-}
 
 instance (Monoid a) => Applicative (Constant a) where
     pure _ = Constant mempty
+    {-# INLINE pure #-}
     Constant x <*> Constant y = Constant (x `mappend` y)
+    {-# INLINE (<*>) #-}
 
 instance (Monoid a) => Monoid (Constant a b) where
     mempty = Constant mempty
+    {-# INLINE mempty #-}
     Constant x `mappend` Constant y = Constant (x `mappend` y)
+    {-# INLINE mappend #-}
 
 #if MIN_VERSION_base(4,8,0)
 instance Bifunctor Constant where
     first f (Constant x) = Constant (f x)
+    {-# INLINE first #-}
     second _ (Constant x) = Constant x
+    {-# INLINE second #-}
 #endif
index d033c81..98c0d6f 100644 (file)
@@ -41,9 +41,11 @@ newtype Reverse f a = Reverse { getReverse :: f a }
 
 instance (Eq1 f) => Eq1 (Reverse f) where
     liftEq eq (Reverse x) (Reverse y) = liftEq eq x y
+    {-# INLINE liftEq #-}
 
 instance (Ord1 f) => Ord1 (Reverse f) where
     liftCompare comp (Reverse x) (Reverse y) = liftCompare comp x y
+    {-# INLINE liftCompare #-}
 
 instance (Read1 f) => Read1 (Reverse f) where
     liftReadsPrec rp rl = readsData $
@@ -61,28 +63,40 @@ instance (Show1 f, Show a) => Show (Reverse f a) where showsPrec = showsPrec1
 -- | Derived instance.
 instance (Functor f) => Functor (Reverse f) where
     fmap f (Reverse a) = Reverse (fmap f a)
+    {-# INLINE fmap #-}
 
 -- | Derived instance.
 instance (Applicative f) => Applicative (Reverse f) where
     pure a = Reverse (pure a)
+    {-# INLINE pure #-}
     Reverse f <*> Reverse a = Reverse (f <*> a)
+    {-# INLINE (<*>) #-}
 
 -- | Derived instance.
 instance (Alternative f) => Alternative (Reverse f) where
     empty = Reverse empty
+    {-# INLINE empty #-}
     Reverse x <|> Reverse y = Reverse (x <|> y)
+    {-# INLINE (<|>) #-}
 
 -- | Fold from right to left.
 instance (Foldable f) => Foldable (Reverse f) where
     foldMap f (Reverse t) = getDual (foldMap (Dual . f) t)
+    {-# INLINE foldMap #-}
     foldr f z (Reverse t) = foldl (flip f) z t
+    {-# INLINE foldr #-}
     foldl f z (Reverse t) = foldr (flip f) z t
+    {-# INLINE foldl #-}
     foldr1 f (Reverse t) = foldl1 (flip f) t
+    {-# INLINE foldr1 #-}
     foldl1 f (Reverse t) = foldr1 (flip f) t
+    {-# INLINE foldl1 #-}
 
 -- | Traverse from right to left.
 instance (Traversable f) => Traversable (Reverse f) where
     traverse f (Reverse t) =
         fmap Reverse . forwards $ traverse (Backwards . f) t
+    {-# INLINE traverse #-}
     sequenceA (Reverse t) =
         fmap Reverse . forwards $ sequenceA (fmap Backwards t)
+    {-# INLINE sequenceA #-}