diff --git a/fay-base.cabal b/fay-base.cabal
--- a/fay-base.cabal
+++ b/fay-base.cabal
@@ -1,5 +1,5 @@
 name:                fay-base
-version:             0.17.0.0
+version:             0.18.0.0
 synopsis:            The base package for Fay.
 description:         The base package for Fay.
                      This package exports Prelude and FFI which you probably want to use with Fay.
@@ -30,4 +30,4 @@
                     ,FFI
                     ,Data.Data
                     ,Data.Ratio
-  build-depends: base == 4.*, fay >= 0.16
+  build-depends: base == 4.*, fay >= 0.18
diff --git a/src/Prelude.hs b/src/Prelude.hs
--- a/src/Prelude.hs
+++ b/src/Prelude.hs
@@ -1,11 +1,10 @@
-{-# LANGUAGE PackageImports #-}
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP                  #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE PackageImports       #-}
 {-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# OPTIONS -w #-}
 
 module Prelude
-#ifndef FAY
   (
   -- Prelude type re-exports
    Base.Char
@@ -26,6 +25,7 @@
   ,(>>=)
   ,(>>)
   ,return
+  ,fail
   ,when
   ,forM_
   ,mapM_
@@ -58,7 +58,7 @@
   ,(/)
   -- Integral
   ,fromIntegral
-  ,fromIntegral
+  ,fromInteger
   -- Bools
   ,(&&)
   ,(||)
@@ -201,15 +201,14 @@
   ,ifThenElse
   ,Fay
   )
-#endif
   where
 
-import                  Fay.Types (Fay)
-import                  Fay.FFI
-import Data.Data
-import qualified "base" Prelude as Base
-import "base" Prelude (Bool(True,False)
-                      ,(||),(&&),seq,Eq,(==),(/=))
+import           Data.Data
+import           Fay.FFI
+import           Fay.Types (Fay)
+import           "base" Prelude   (Bool (True, False), Eq, seq, (&&), (/=),
+                                   (==), (||))
+import qualified "base" Prelude   as Base
 
 --------------------------------------------------------------------------------
 -- Fixities
@@ -269,17 +268,20 @@
 -- Monads
 
 -- | Monomorphic bind for Fay.
-(>>=) :: Fay a -> (a -> Fay b) -> Fay b
-(>>=) = ffi "Fay$$bind(%1)(%2)"
+(>>=) :: Ptr (Fay a) -> Ptr (a -> Fay b) -> Ptr (Fay b)
+(>>=) = ffi "Fay$$_(Fay$$bind(%1)(%2))"
 
 -- | Monomorphic then for Fay.
-(>>) :: Fay a -> Fay b -> Fay b
-(>>) = ffi "Fay$$then(%1)(%2)"
+(>>) :: Ptr (Fay a) -> Ptr (Fay b) -> Ptr (Fay b)
+(>>) = ffi "Fay$$_(Fay$$then(%1)(%2))"
 
 -- | Monomorphic return for Fay.
 return :: a -> Fay a
 return = ffi "Fay$$return(%1)"
 
+fail :: String -> Fay a
+fail = error
+
 when :: Bool -> Fay a -> Fay ()
 when p m = if p then m >> return () else return ()
 
@@ -389,10 +391,10 @@
 
 instance Integral Int
 
-fromIntegral :: Int -> Double
+fromIntegral :: (Num a, Num b) => Ptr a -> Ptr b
 fromIntegral = ffi "%1"
 
-fromInteger :: Int -> Double
+fromInteger :: Num a => Ptr Base.Integer -> Ptr a
 fromInteger = ffi "%1"
 
 --------------------------------------------------------------------------------