use an inline unsafePerformIO

1 files changed, 15 insertions, 8 deletions

diff --git a/lib/Data/Packed/Foreign.hs b/lib/Data/Packed/Foreign.hs
index fe171b1..a94a979 100644
--- a/lib/Data/Packed/Foreign.hs
+++ b/lib/Data/Packed/Foreign.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE MagicHash, UnboxedTuples #-}
 -- | FFI and hmatrix helpers.
 --
 -- Sample usage, to upload a perspective matrix to a shader.
@@ -8,9 +9,14 @@
 module Data.Packed.Foreign where
 import Data.Packed.Internal
 import qualified Data.Vector.Storable as S
-import System.IO.Unsafe (unsafePerformIO)
 import Foreign (Ptr, ForeignPtr, Storable)
 import Foreign.C.Types (CInt)
+import GHC.Base (IO(..), realWorld#)
+
+{-# INLINE unsafeInlinePerformIO #-}
+unsafeInlinePerformIO :: IO a -> a
+unsafeInlinePerformIO (IO f) = case f realWorld# of
+    (# _, x #) -> x
 
 {-# INLINE app #-}
 -- | Only useful since it is left associated with a precedence of 1, unlike 'Prelude.$', which is right associative.
@@ -41,30 +47,30 @@ app f = f
 
 {-# INLINE appVector #-}
 appVector :: Storable a => (Ptr a -> b) -> Vector a -> b
-appVector f x = unsafePerformIO (S.unsafeWith x (return . f))
+appVector f x = unsafeInlinePerformIO (S.unsafeWith x (return . f))
 
 {-# INLINE appVectorLen #-}
 appVectorLen :: Storable a => (CInt -> Ptr a -> b) -> Vector a -> b
-appVectorLen f x = unsafePerformIO (S.unsafeWith x (return . f (fromIntegral (S.length x))))
+appVectorLen f x = unsafeInlinePerformIO (S.unsafeWith x (return . f (fromIntegral (S.length x))))
 
 {-# INLINE appMatrix #-}
 appMatrix :: Element a => (Ptr a -> b) -> Matrix a -> b
-appMatrix f x = unsafePerformIO (S.unsafeWith (flatten x) (return . f))
+appMatrix f x = unsafeInlinePerformIO (S.unsafeWith (flatten x) (return . f))
 
 {-# INLINE appMatrixLen #-}
 appMatrixLen :: Element a => (CInt -> CInt -> Ptr a -> b) -> Matrix a -> b
-appMatrixLen f x = unsafePerformIO (S.unsafeWith (flatten x) (return . f r c))
+appMatrixLen f x = unsafeInlinePerformIO (S.unsafeWith (flatten x) (return . f r c))
   where
     r = fromIntegral (rows x)
     c = fromIntegral (cols x)
 
 {-# INLINE appMatrixRaw #-}
 appMatrixRaw :: Storable a => Matrix a -> (Ptr a -> b) -> b
-appMatrixRaw x f = unsafePerformIO (S.unsafeWith (xdat x) (return . f))
+appMatrixRaw x f = unsafeInlinePerformIO (S.unsafeWith (xdat x) (return . f))
 
 {-# INLINE appMatrixRawLen #-}
 appMatrixRawLen :: Element a => (CInt -> CInt -> Ptr a -> b) -> Matrix a -> b
-appMatrixRawLen f x = unsafePerformIO (S.unsafeWith (xdat x) (return . f r c))
+appMatrixRawLen f x = unsafeInlinePerformIO (S.unsafeWith (xdat x) (return . f r c))
   where
     r = fromIntegral (rows x)
     c = fromIntegral (cols x)
@@ -75,7 +81,8 @@ infixl 1 `appMatrix`
 infixl 1 `appMatrixRaw`
 
 {-# INLINE unsafeMatrixToVector #-}
--- | This will disregard the order of the matrix, and simply return it as-is.
+-- | This will disregard the order of the matrix, and simply return it as-is. 
+-- If the order of the matrix is RowMajor, this function is identical to 'flatten'.
 unsafeMatrixToVector :: Matrix a -> Vector a
 unsafeMatrixToVector = xdat