Make use of assert conditional

This turns out to make about a 10% difference to performance, even
though the GHC docs claim it shouldn't :-(

--HG--
extra : convert_revision : 446f05ea889a715272cd709cbd2d3b11260df7ba

Data/Text.hs

@@ -174,7 +174,9 @@ import Prelude (Char, Bool(..), Functor(..), Int, Maybe(..), String,
 #if defined(HAVE_DEEPSEQ)
 import Control.DeepSeq (NFData)
 #endif
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import Data.Char (isSpace)
 import Data.Data (Data(gfoldl, toConstr, gunfold, dataTypeOf))
 #if __GLASGOW_HASKELL__ >= 612
@@ -395,7 +397,11 @@ init (Text arr off len) | len <= 0                   = emptyError "init"
 -- | /O(1)/ Tests whether a 'Text' is empty or not.  Subject to
 -- fusion.
 null :: Text -> Bool
-null (Text _arr _off len) = assert (len >= 0) $ len <= 0
+null (Text _arr _off len) =
+#if defined(ASSERTS)
+    assert (len >= 0) $
+#endif
+    len <= 0
 {-# INLINE [1] null #-}
 
 {-# RULES

Data/Text/Array.hs

@@ -42,19 +42,20 @@ module Data.Text.Array
     , unsafeWrite
     ) where
 
-#if 0
-#define BOUNDS_CHECKING
+#if defined(ASSERTS)
 -- This fugly hack is brought by GHC's apparent reluctance to deal
 -- with MagicHash and UnboxedTuples when inferring types. Eek!
-#define CHECK_BOUNDS(_func_,_len_,_k_) \
+# define CHECK_BOUNDS(_func_,_len_,_k_) \
 if (_k_) < 0 || (_k_) >= (_len_) then error ("Data.Text.Array." ++ (_func_) ++ ": bounds error, offset " ++ show (_k_) ++ ", length " ++ show (_len_)) else
 #else
-#define CHECK_BOUNDS(_func_,_len_,_k_)
+# define CHECK_BOUNDS(_func_,_len_,_k_)
 #endif
 
 #include "MachDeps.h"
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import Data.Text.UnsafeShift (shiftL)
 import GHC.Base (ByteArray#, MutableByteArray#, Int(..),
                  indexWord16Array#, newByteArray#,
@@ -92,10 +93,14 @@ unsafeFreeze :: MArray s -> ST s (Array)
 
 -- | Create an uninitialized mutable array.
 unsafeNew :: forall s. Int -> ST s (MArray s)
-unsafeNew n = assert (n >= 0) . ST $ \s1# ->
-   case bytesInArray n of
-     len@(I# len#) ->
-#if defined(BOUNDS_CHECKING)
+unsafeNew n =
+#if defined(ASSERTS)
+    assert (n >= 0) .
+#endif
+    ST $ \s1# ->
+    case bytesInArray n of
+      len@(I# len#) ->
+#if defined(ASSERTS)
          if len < 0 then error (show ("unsafeNew",len)) else
 #endif
          case newByteArray# len# s1# of
@@ -181,8 +186,10 @@ copy src dest
 -- | Unsafely copy the elements of an array.
 unsafeCopy :: MArray s -> Int -> MArray s -> Int -> Int -> ST s ()
 unsafeCopy src sidx dest didx count =
+#if defined(ASSERTS)
     assert (sidx + count <= length src) .
     assert (didx + count <= length dest) $
+#endif
     copy_loop sidx didx 0
     where
       copy_loop !i !j !c

Data/Text/Encoding/Fusion.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE BangPatterns, Rank2Types #-}
+{-# LANGUAGE BangPatterns, CPP, Rank2Types #-}
 
 -- |
 -- Module      : Data.Text.Encoding.Fusion
@@ -31,7 +31,9 @@ module Data.Text.Encoding.Fusion
     , module Data.Text.Encoding.Fusion.Common
     ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import Data.ByteString.Internal (ByteString(..), mallocByteString, memcpy)
 import Data.Text.Fusion (Step(..), Stream(..))
 import Data.Text.Fusion.Size
@@ -182,7 +184,11 @@ unstream (Stream next s0 len) = unsafePerformIO $ do
       {-# NOINLINE trimUp #-}
       trimUp fp _ off = return $! PS fp 0 off
       copy0 :: ForeignPtr Word8 -> Int -> Int -> IO (ForeignPtr Word8)
-      copy0 !src !srcLen !destLen = assert (srcLen <= destLen) $ do
+      copy0 !src !srcLen !destLen =
+#if defined(ASSERTS)
+        assert (srcLen <= destLen) $
+#endif
+        do
           dest <- mallocByteString destLen
           withForeignPtr src  $ \src'  ->
               withForeignPtr dest $ \dest' ->

Data/Text/Encoding/Fusion/Common.hs

@@ -28,9 +28,9 @@ module Data.Text.Encoding.Fusion.Common
     ) where
 
 import Data.Bits ((.&.))
-import Data.Char (ord)
 import Data.Text.Fusion (Step(..), Stream(..))
 import Data.Text.Fusion.Internal (M(..), S(..))
+import Data.Text.UnsafeChar (ord)
 import Data.Text.UnsafeShift (shiftR)
 import Data.Word (Word8)
 import qualified Data.Text.Encoding.Utf8 as U8

Data/Text/Encoding/Utf8.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE CPP, MagicHash #-}
 
 -- |
 -- Module      : Data.Text.Encoding.Utf16
@@ -30,9 +30,11 @@ module Data.Text.Encoding.Utf8
     , validate4
     ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
-import Data.Char (ord)
+#endif
 import Data.Bits ((.&.))
+import Data.Text.UnsafeChar (ord)
 import Data.Text.UnsafeShift (shiftR)
 import GHC.Exts
 import GHC.Word (Word8(..))
@@ -47,22 +49,34 @@ between x y z = x >= y && x <= z
 {-# INLINE between #-}
 
 ord2   :: Char -> (Word8,Word8)
-ord2 c = assert (n >= 0x80 && n <= 0x07ff) (x1,x2)
+ord2 c =
+#if defined(ASSERTS)
+    assert (n >= 0x80 && n <= 0x07ff)
+#endif
+    (x1,x2)
     where
       n  = ord c
       x1 = fromIntegral $ (n `shiftR` 6) + 0xC0
       x2 = fromIntegral $ (n .&. 0x3F)   + 0x80
 
 ord3   :: Char -> (Word8,Word8,Word8)
-ord3 c = assert (n >= 0x0800 && n <= 0xffff) (x1,x2,x3)
+ord3 c =
+#if defined(ASSERTS)
+    assert (n >= 0x0800 && n <= 0xffff)
+#endif
+    (x1,x2,x3)
     where
       n  = ord c
       x1 = fromIntegral $ (n `shiftR` 12) + 0xE0
       x2 = fromIntegral $ ((n `shiftR` 6) .&. 0x3F) + 0x80
       x3 = fromIntegral $ (n .&. 0x3F) + 0x80
 
 ord4   :: Char -> (Word8,Word8,Word8,Word8)
-ord4 c = assert (n >= 0x10000) (x1,x2,x3,x4)
+ord4 c =
+#if defined(ASSERTS)
+    assert (n >= 0x10000)
+#endif
+    (x1,x2,x3,x4)
     where
       n  = ord c
       x1 = fromIntegral $ (n `shiftR` 18) + 0xF0

Data/Text/Foreign.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE BangPatterns, CPP #-}
 -- |
 -- Module      : Data.Text.Foreign
 -- Copyright   : (c) Bryan O'Sullivan 2009
@@ -25,7 +25,9 @@ module Data.Text.Foreign
     , unsafeCopyToPtr
     ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import Control.Monad.ST (unsafeIOToST)
 import Data.Text.Internal (Text(..), empty)
 import qualified Data.Text.Array as A
@@ -53,7 +55,11 @@ fromPtr :: Ptr Word16           -- ^ source array
         -> Int                  -- ^ length of source array (in 'Word16' units)
         -> IO Text
 fromPtr _   0   = return empty
-fromPtr ptr len = assert (len > 0) $ return (Text arr 0 len)
+fromPtr ptr len =
+#if defined(ASSERTS)
+    assert (len > 0) $
+#endif
+    return $! Text arr 0 len
   where
     arr = A.run (A.unsafeNew len >>= copy)
     copy marr = loop ptr 0
@@ -68,6 +74,7 @@ fromPtr ptr len = assert (len > 0) $ return (Text arr 0 len)
 -- 'unsafeCopyToPtr'.
 lengthWord16 :: Text -> Int
 lengthWord16 (Text _arr _off len) = len
+{-# INLINE lengthWord16 #-}
 
 -- | /O(n)/ Copy a 'Text' to an array.  The array is assumed to be big
 -- enough to hold the contents of the entire 'Text'.

Data/Text/Fusion.hs

@@ -47,9 +47,8 @@ import Prelude (Bool(..), Char, Maybe(..), Monad(..), Int,
                 Num(..), Ord(..), ($), (&&),
                 fromIntegral, otherwise)
 import Data.Bits ((.&.))
-import Data.Char (ord)
 import Data.Text.Internal (Text(..))
-import Data.Text.UnsafeChar (unsafeChr, unsafeWrite)
+import Data.Text.UnsafeChar (ord, unsafeChr, unsafeWrite)
 import Data.Text.UnsafeShift (shiftL, shiftR)
 import qualified Data.Text.Array as A
 import qualified Data.Text.Fusion.Common as S

Data/Text/Fusion/Size.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# OPTIONS_GHC -fno-warn-missing-methods #-}
 -- |
 -- Module      : Data.Text.Fusion.Internal
@@ -26,19 +27,29 @@ module Data.Text.Fusion.Size
     , isEmpty
     ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 
 data Size = Exact {-# UNPACK #-} !Int -- ^ Exact size.
           | Max   {-# UNPACK #-} !Int -- ^ Upper bound on size.
           | Unknown                   -- ^ Unknown size.
             deriving (Eq, Show)
 
 exactSize :: Int -> Size
-exactSize n = assert (n >= 0) Exact n
+exactSize n =
+#if defined(ASSERTS)
+    assert (n >= 0)
+#endif
+    Exact n
 {-# INLINE exactSize #-}
 
 maxSize :: Int -> Size
-maxSize n = assert (n >= 0) Max n
+maxSize n =
+#if defined(ASSERTS)
+    assert (n >= 0)
+#endif
+    Max n
 {-# INLINE maxSize #-}
 
 unknownSize :: Size

Data/Text/Internal.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE CPP, DeriveDataTypeable #-}
 
 -- |
 -- Module      : Data.Text.Internal
@@ -28,7 +28,9 @@ module Data.Text.Internal
     , showText
     ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import qualified Data.Text.Array as A
 import Data.Typeable (Typeable)
 
@@ -42,13 +44,15 @@ data Text = Text
 -- | Smart constructor.
 text :: A.Array -> Int -> Int -> Text
 text arr off len =
-    assert (len >= 0) .
-    assert (off >= 0) .
-    assert (alen == 0 || len == 0 || off < alen) .
-    assert (len == 0 || c < 0xDC00 || c > 0xDFFF) $
-    Text arr off len
-  where c    = A.unsafeIndex arr off
-        alen = A.length arr
+#if defined(ASSERTS)
+  let c    = A.unsafeIndex arr off
+      alen = A.length arr
+  in assert (len >= 0) .
+     assert (off >= 0) .
+     assert (alen == 0 || len == 0 || off < alen) .
+     assert (len == 0 || c < 0xDC00 || c > 0xDFFF) $
+#endif
+     Text arr off len
 {-# INLINE text #-}
 
 -- | /O(1)/ The empty 'Text'.

Data/Text/Lazy/Builder.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE BangPatterns, Rank2Types #-}
+{-# LANGUAGE BangPatterns, CPP, Rank2Types #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -29,7 +29,9 @@ module Data.Text.Lazy.Builder
    , flush
    ) where
 
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import Control.Monad.ST (ST, runST)
 import Data.Bits ((.&.))
 import Data.Char (ord)
@@ -259,8 +261,10 @@ newBuffer size = do
 -- | Unsafely copy the elements of an array.
 unsafeCopy :: A.Array -> Int -> A.MArray s -> Int -> Int -> ST s ()
 unsafeCopy src sidx dest didx count =
+#if defined(ASSERTS)
     assert (sidx + count <= A.length src) .
     assert (didx + count <= A.length dest) $
+#endif
     copy_loop sidx didx 0
   where
     copy_loop !i !j !c
@@ -274,12 +278,16 @@ unsafeCopy src sidx dest didx count =
 unsafeWrite :: A.MArray s -> Int -> Char -> ST s Int
 unsafeWrite marr i c
     | n < 0x10000 = do
-        assert (i >= 0) . assert (i < A.length marr) $
-          A.unsafeWrite marr i (fromIntegral n)
+#if defined(ASSERTS)
+        assert (i >= 0) . assert (i < A.length marr) $ return ()
+#endif
+        A.unsafeWrite marr i (fromIntegral n)
         return 1
     | otherwise = do
-        assert (i >= 0) . assert (i < A.length marr - 1) $
-          A.unsafeWrite marr i lo
+#if defined(ASSERTS)
+        assert (i >= 0) . assert (i < A.length marr - 1) $ return ()
+#endif
+        A.unsafeWrite marr i lo
         A.unsafeWrite marr (i+1) hi
         return 2
     where n = ord c

Data/Text/Lazy/Encoding/Fusion.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE BangPatterns, Rank2Types #-}
+{-# LANGUAGE BangPatterns, CPP, Rank2Types #-}
 
 -- |
 -- Module      : Data.Text.Lazy.Encoding.Fusion
@@ -43,7 +43,9 @@ import System.IO.Unsafe (unsafePerformIO)
 import Foreign.ForeignPtr (withForeignPtr, ForeignPtr)
 import Foreign.Storable (pokeByteOff)
 import Data.ByteString.Internal (mallocByteString, memcpy)
+#if defined(ASSERTS)
 import Control.Exception (assert)
+#endif
 import qualified Data.ByteString.Internal as B
 
 data S = S0
@@ -123,7 +125,11 @@ unstreamChunks chunkSize (Stream next s0 len0) = chunk s0 (upperBound 4 len0)
               loop n' (off+1) s fp'
             trimUp fp off = B.PS fp 0 off
             copy0 :: ForeignPtr Word8 -> Int -> Int -> IO (ForeignPtr Word8)
-            copy0 !src !srcLen !destLen = assert (srcLen <= destLen) $ do
+            copy0 !src !srcLen !destLen =
+#if defined(ASSERTS)
+              assert (srcLen <= destLen) $
+#endif
+              do
                 dest <- mallocByteString destLen
                 withForeignPtr src  $ \src'  ->
                     withForeignPtr dest $ \dest' ->