diff --git a/layered-state.cabal b/layered-state.cabal
--- a/layered-state.cabal
+++ b/layered-state.cabal
@@ -2,10 +2,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 9aa62e9756668f40566d023e7ca6588ef4bf863fb729fa397c4cd36ad4fff77b
+-- hash: f475bf6f0f3aa7d1f1fc658299308f47b436a4a2c625395df55e3020b62749d4
 
 name:           layered-state
-version:        1.1.2
+version:        1.1.3
 synopsis:       Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types.
 category:       Data
 stability:      experimental
diff --git a/src/Control/Monad/State/Layered.hs b/src/Control/Monad/State/Layered.hs
--- a/src/Control/Monad/State/Layered.hs
+++ b/src/Control/Monad/State/Layered.hs
@@ -7,6 +7,7 @@
 {-# LANGUAGE TypeInType             #-}
 {-# LANGUAGE RankNTypes             #-}
 {-# LANGUAGE BangPatterns #-}
+
 {-# EXT      InlineAll              #-}
 -- {-# LANGUAGE Strict #-} -- https://ghc.haskell.org/trac/ghc/ticket/14815#ticket
 
@@ -144,18 +145,18 @@
 stateT = StateT . S.StateT ; {-# INLINE stateT #-}
 
 runT  :: ∀ s m a.              StateT s m a -> s -> m (a, s)
-evalT :: ∀ s m a. Functor m => StateT s m a -> s -> m a
-execT :: ∀ s m a. Functor m => StateT s m a -> s -> m s
-runT    = S.runStateT  . unwrap ; {-# INLINE runT  #-}
-evalT m = fmap fst . runT m     ; {-# INLINE evalT #-}
-execT m = fmap snd . runT m     ; {-# INLINE execT #-}
+evalT :: ∀ s m a. S.Monad m => StateT s m a -> s -> m a
+execT :: ∀ s m a. S.Monad m => StateT s m a -> s -> m s
+runT  = S.runStateT . unwrap ; {-# INLINE runT  #-}
+evalT !m !s = let fst (!a, !_) = a in fst <$> runT m s ; {-# INLINE evalT #-}
+execT !m !s = let snd (!_, !a) = a in snd <$> runT m s ; {-# INLINE execT #-}
 
 runDefT  :: ∀ s m a.            Default s  => StateT s m a -> m (a, s)
-evalDefT :: ∀ s m a. (Functor m,Default s) => StateT s m a -> m a
-execDefT :: ∀ s m a. (Functor m,Default s) => StateT s m a -> m s
-runDefT  = flip runT  def ; {-# INLINE runDefT  #-}
-evalDefT = flip evalT def ; {-# INLINE evalDefT #-}
-execDefT = flip execT def ; {-# INLINE execDefT #-}
+evalDefT :: ∀ s m a. (S.Monad m,Default s) => StateT s m a -> m a
+execDefT :: ∀ s m a. (S.Monad m,Default s) => StateT s m a -> m s
+runDefT  !s = runT  s def ; {-# INLINE runDefT  #-}
+evalDefT !s = evalT s def ; {-# INLINE evalDefT #-}
+execDefT !s = execT s def ; {-# INLINE execDefT #-}
 
 run  :: ∀ s a. State s a -> s -> (a, s)
 eval :: ∀ s a. State s a -> s -> a