diff --git a/Control/Monad/ST/Trans.hs b/Control/Monad/ST/Trans.hs
--- a/Control/Monad/ST/Trans.hs
+++ b/Control/Monad/ST/Trans.hs
@@ -43,6 +43,7 @@
       -- * Unsafe Operations
       unsafeIOToSTT,
       unsafeSTToIO,
+      unsafeSTTToIO,
       unsafeSTRefToIORef,
       unsafeIORefToSTRef
       )where
@@ -51,7 +52,12 @@
 import GHC.Arr (Ix(..), safeRangeSize, safeIndex, 
                 Array(..), arrEleBottom)
 import qualified GHC.Arr as STArray
-import GHC.ST hiding (runST, liftST)
+import GHC.ST hiding
+       (runST, liftST
+#if !MIN_VERSION_base(4,7,0)
+        , unsafeSTToIO
+#endif
+        )
 import Control.Monad.ST hiding (runST)
 
 import Data.STRef (STRef)
@@ -73,19 +79,22 @@
 isTrue# x = x
 #endif
 
-
+{-# INLINE newSTRef #-}
 -- | Create a new reference
 newSTRef :: (Applicative m, Monad m) => a -> STT s m (STRef s a)
 newSTRef init = liftST (STRef.newSTRef init)
 
+{-# INLINE readSTRef #-}
 -- | Reads the value of a reference
 readSTRef :: (Applicative m, Monad m) => STRef s a -> STT s m a
 readSTRef ref = liftST (STRef.readSTRef ref)
 
+{-# INLINE writeSTRef #-}
 -- | Modifies the value of a reference
 writeSTRef :: (Applicative m, Monad m) => STRef s a -> a -> STT s m ()
 writeSTRef ref a = liftST (STRef.writeSTRef ref a)
 
+{-# DEPRECATED runST "Use runSTT instead" #-}
 {-# NOINLINE runST #-}
 -- | Executes a computation in the 'STT' monad transformer
 runST :: Monad m => (forall s. STT s m a) -> m a
@@ -103,76 +112,90 @@
 
 -- Mutable arrays.
 
+{-# INLINE newSTArray #-}
 -- | Creates a new mutable array
 newSTArray :: (Ix i, Applicative m, Monad m) =>
               (i,i) -> e -> STT s m (STArray s i e)
 newSTArray bounds init = liftST (newArray bounds init)
 
+{-# INLINE boundsSTArray #-}
 -- | Returns the lowest and highest indices of the array
 boundsSTArray :: STArray s i e -> (i,i)
 boundsSTArray = STArray.boundsSTArray
 
+{-# INLINE numElementsSTArray #-}
 -- | Returns the number of elements in the array
 numElementsSTArray :: STArray s i e -> Int
 numElementsSTArray = STArray.numElementsSTArray
 
+{-# INLINE readSTArray #-}
 -- | Retrieves an element from the array
 readSTArray :: (Ix i, Applicative m, Monad m) =>
                STArray s i e -> i -> STT s m e
 readSTArray arr i = liftST (readArray arr i)
 
+{-# INLINE unsafeReadSTArray #-}
 unsafeReadSTArray :: (Ix i, Applicative m, Monad m) =>
                      STArray s i e -> Int -> STT s m e
 unsafeReadSTArray arr i = liftST (STArray.unsafeReadSTArray arr i)
 
+{-# INLINE writeSTArray #-}
 -- | Modifies an element in the array
 writeSTArray :: (Ix i, Applicative m, Monad m) =>
                 STArray s i e -> i -> e -> STT s m ()
 writeSTArray arr i e = liftST (writeArray arr i e)
 
+{-# INLINE unsafeWriteSTArray #-}
 unsafeWriteSTArray :: (Ix i, Applicative m, Monad m) =>
                       STArray s i e -> Int -> e -> STT s m ()
 unsafeWriteSTArray arr i e = liftST (STArray.unsafeWriteSTArray arr i e)
 
+{-# INLINE freezeSTArray #-}
 -- | Copy a mutable array and turn it into an immutable array
 freezeSTArray :: (Ix i, Applicative m, Monad m) =>
                  STArray s i e -> STT s m (Array i e)
 freezeSTArray arr = liftST (STArray.freezeSTArray arr)
 
+{-# INLINE unsafeFreezeSTArray #-}
 unsafeFreezeSTArray :: (Ix i, Applicative m, Monad m) =>
                        STArray s i e -> STT s m (Array i e)
 unsafeFreezeSTArray arr = liftST (STArray.unsafeFreezeSTArray arr)
 
+{-# INLINE thawSTArray #-}
 -- | Copy an immutable array and turn it into a mutable array
 thawSTArray :: (Ix i, Applicative m, Monad m) =>
                Array i e -> STT s m (STArray s i e)
 thawSTArray arr = liftST (STArray.thawSTArray arr)
 
+{-# INLINE unsafeThawSTArray #-}
 unsafeThawSTArray :: (Ix i, Applicative m, Monad m) =>
                      Array i e -> STT s m (STArray s i e)
 unsafeThawSTArray arr = liftST (STArray.unsafeThawSTArray arr)
 
+{-# INLINE runSTArray #-}
 -- | A safe way to create and work with a mutable array before returning an
 -- immutable array for later perusal.  This function avoids copying
 -- the array before returning it.
 runSTArray :: (Ix i, Applicative m, Monad m)
            => (forall s . STT s m (STArray s i e))
            -> m (Array i e)
-runSTArray st = runST (st >>= unsafeFreezeSTArray)
+runSTArray st = runSTT (st >>= unsafeFreezeSTArray)
 
 
 {-# NOINLINE unsafeIOToSTT #-} 
 unsafeIOToSTT :: (Monad m) => IO a -> STT s m a
 unsafeIOToSTT m = return $! unsafePerformIO m
 
+{-# DEPRECATED unsafeSTToIO "Use unsafeSTTToIO instead" #-}
 unsafeSTToIO :: STT s IO a -> IO a
-unsafeSTToIO m = runST $ unsafeCoerce m
+unsafeSTToIO m = runSTT $ unsafeCoerce m
 
+unsafeSTTToIO :: STT s IO a -> IO a
+unsafeSTTToIO m = runSTT $ unsafeCoerce m
+
 -- This should work, as STRef and IORef should have identical internal representation
 unsafeSTRefToIORef  :: STRef s a -> IORef a
 unsafeSTRefToIORef ref = unsafeCoerce ref
 
 unsafeIORefToSTRef :: IORef a -> STRef s a
 unsafeIORefToSTRef ref = unsafeCoerce ref
-
-
diff --git a/STMonadTrans.cabal b/STMonadTrans.cabal
--- a/STMonadTrans.cabal
+++ b/STMonadTrans.cabal
@@ -1,5 +1,5 @@
 name:		STMonadTrans
-version:	0.4.1
+version:	0.4.2
 cabal-version:  >= 1.8
 license:	BSD3
 license-file:	LICENSE
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,10 @@
+0.4.2
+
+  * Deprecate runST and unsafeSTToIO in favor of
+    runSTT and unsafeSTTToIO.
+  * Fix compilation for GHC 7.6.3. Thanks to Andrés Sicard-Ramírez.
+  * Added INLINE pragmas
+
 0.4.1
 
   * Add Applicative constraints to be compatible with GHC 7.8.4