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
@@ -1,6 +1,5 @@
 {-# LANGUAGE MagicHash, UnboxedTuples, Rank2Types, FlexibleInstances,
-    MultiParamTypeClasses #-}
-{-# OPTIONS_GHC -fallow-undecidable-instances #-}
+    MultiParamTypeClasses, UndecidableInstances, RecursiveDo #-}
 {- |
    Module      :  Control.Monad.ST.Trans
    Copyright   :  Josef Svenningsson 2008
@@ -13,6 +12,13 @@
 
    This library provides a monad transformer version of the ST monad.
 
+   Warning! This monad transformer should not be used with monads that
+   can contain multiple answers, like the list monad. The reason is that 
+   the will be duplicated across the different answers and this cause
+   Bad Things to happen (such as loss of referential transparency). Safe 
+   monads include the monads State, Reader, Writer, Maybe and 
+   combinations of their corresponding monad transformers.
+
 -}
 module Control.Monad.ST.Trans(
       -- * The ST Monad Transformer
@@ -32,19 +38,33 @@
       numElementsSTArray,
       freezeSTArray,
       thawSTArray,
-      runSTArray
+      runSTArray,
+      -- * Unsafe Operations
+      unsafeIOToSTT,
+      unsafeSTToIO,
+      unsafeSTRefToIORef,
+      unsafeIORefToSTRef
       )where
 
 import GHC.Base
 import GHC.Arr (Ix(..), safeRangeSize, safeIndex, 
                 Array(..), arrEleBottom)
 
+import Control.Monad.Fix
 import Control.Monad.Trans
 import Control.Monad.Error.Class
 import Control.Monad.Reader.Class
 import Control.Monad.State.Class
 import Control.Monad.Writer.Class
 
+import Control.Applicative
+
+import Data.IORef
+
+import Unsafe.Coerce
+import System.IO.Unsafe
+
+
 -- | 'STT' is the monad transformer providing polymorphic updateable references
 newtype STT s m a = STT (State# s -> m (STTRet s a))
 unSTT (STT f) = f
@@ -63,7 +83,28 @@
   lift m = STT $ \st ->
    do a <- m
       return (STTRet st a)
+      
+liftSTT :: STT s m a -> State# s -> m (STTRet s a)
+liftSTT (STT m) s = m s
 
+instance (MonadFix m) => MonadFix (STT s m) where
+  mfix k = STT $ \ s -> mdo
+    ans@(STTRet _ r) <- liftSTT (k r) s
+    return ans
+
+instance Functor (STTRet s) where
+  fmap f (STTRet s a) = STTRet s (f a)
+
+instance Functor m => Functor (STT s m) where
+  fmap f (STT g) = STT $ \s# -> (fmap . fmap) f (g s#)
+
+instance (Monad m, Functor m) => Applicative (STT s m) where
+  pure a = STT $ \s# -> return (STTRet s# a)
+  (STT m) <*> (STT n) = STT $ \s1 ->
+                        do (STTRet s2 f) <- m s1
+                           (STTRet s3 x) <- n s2
+                           return (STTRet s3 (f x))
+
 -- | Mutable references
 data STRef s a = STRef (MutVar# s a)
 
@@ -202,4 +243,20 @@
            => (forall s . STT s m (STArray s i e))
            -> m (Array i e)
 runSTArray st = runST (st >>= unsafeFreezeSTArray)
+
+
+{-# NOINLINE unsafeIOToSTT #-} 
+unsafeIOToSTT :: (Monad m) => IO a -> STT s m a
+unsafeIOToSTT m = return $! unsafePerformIO m
+
+unsafeSTToIO :: STT s IO a -> IO a
+unsafeSTToIO m = runST $ 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,25 +1,37 @@
 name:		STMonadTrans
-version:	0.1
+version:	0.2
+cabal-version:  >= 1.6
 license:	BSD3
 license-file:	LICENSE
 author:		Josef Svenningsson
 maintainer:	josef.svenningsson@gmail.com
 category:	Monads
-synopsis:	A monad transformer version of the ST monad
-description:	A monad transformer version of the ST monad
-cabal-version: >=1.2
 build-type:	Simple
+synopsis:	A monad transformer version of the ST monad
+description:	
+   A monad transformer version of the ST monad
 
+   Warning! This monad transformer should not be used with monads that
+   can contain multiple answers, like the list monad. The reason is that 
+   the will be duplicated across the different answers and this cause
+   Bad Things to happen (such as loss of referential transparency). Safe 
+   monads include the monads State, Reader, Writer, Maybe and 
+   combinations of their corresponding monad transformers.
+
+source-repository head
+  type:     darcs
+  location: http://patch-tag.com/r/josef/STMonadTrans
+
 flag splitBase
   description: Choose the new smaller, split-up base package.
 
 library
   if flag(splitBase)
-    build-depends: base >= 3, mtl, array
+    build-depends: base >= 3, base < 4, mtl, array
   else
     build-depends: base < 3
 
   exposed-modules:	Control.Monad.ST.Trans
   extensions:	MagicHash, UnboxedTuples, Rank2Types, FlexibleInstances, 
-        MultiParamTypeClasses
+        MultiParamTypeClasses, UndecidableInstances