carray 0.1.4 → 0.1.5

raw patch · 2 files changed

+11/−42 lines, 2 filesdep ~arraydep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: array, base

API changes (from Hackage documentation)

Files

• Data/Array/CArray/Base.hs +9/−40
• carray.cabal +2/−2

@@ -1,5 +1,6 @@ {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, MagicHash,-  FlexibleInstances, FlexibleContexts, UnboxedTuples, DeriveDataTypeable, CPP #-}+  FlexibleInstances, FlexibleContexts, UnboxedTuples, DeriveDataTypeable, CPP,+  BangPatterns #-} #ifdef __GLASGOW_HASKELL__ #if __GLASGOW_HASKELL__ < 610 {-# OPTIONS_GHC -frewrite-rules #-}@@ -43,7 +44,7 @@ import Data.Ix.Shapable import Data.Array.Base import Data.Array.MArray-import Data.Array.IArray+import Data.Array.IArray        () import qualified Data.ByteString.Internal as S import Data.Binary import Data.Complex@@ -54,11 +55,9 @@ import Foreign.Ptr import Foreign.Marshal.Alloc import Foreign.Marshal.Array    (copyArray)-import Data.Word                (Word8,Word)+import Data.Word                ()  import Data.Generics            (Data(..), Typeable(..))-import GHC.Base                 (realWorld#, Addr#)-import GHC.IOBase               (IO(..)) import GHC.Ptr                  (Ptr(..)) import GHC.ForeignPtr           (ForeignPtr(..), mallocPlainForeignPtrBytes) @@ -150,8 +149,8 @@           go dummy (l,u) | safe = Just (CArray l u n fp)                          | otherwise = Nothing               where n = rangeSize (l,u)-                    ((ForeignPtr addr contents), off, len) = S.toForeignPtr bs-                    p@(Ptr addr') = Ptr addr `plusPtr` off+                    !((ForeignPtr addr contents), off, len) = S.toForeignPtr bs+                    !p@(Ptr addr') = Ptr addr `plusPtr` off                     fp = ForeignPtr addr' contents                     safe = sizeOf dummy * n <= len && p == p `alignPtr` alignment dummy @@ -200,7 +199,7 @@     {-# NOINLINE unsafeArray #-}     unsafeArray lu ies = unsafePerformIO $ unsafeArrayCArray lu ies (zeroElem (undefined :: e))     {-# INLINE unsafeAt #-}-    unsafeAt (CArray _ _ _ fp) i = unsafeInlinePerformIO $+    unsafeAt (CArray _ _ _ fp) i = S.inlinePerformIO $                                    withForeignPtr fp $ \a -> peekElemOff a i     {-# NOINLINE unsafeReplace #-}     unsafeReplace arr ies = unsafePerformIO $ unsafeReplaceCArray arr ies@@ -404,7 +403,7 @@ -- transparency! {-# INLINE mapCArrayInPlace #-} mapCArrayInPlace :: (Ix i, IArray CArray e, Storable e) => (e -> e) -> CArray i e -> CArray i e-mapCArrayInPlace f a = unsafeInlinePerformIO $ do+mapCArrayInPlace f a = S.inlinePerformIO $ do     withCArray a $ \p ->         forM_ [0 .. size a - 1] $ \i ->             peekElemOff p i >>= pokeElemOff p i . f@@ -499,36 +498,6 @@     abs_ = abs  --- | This variant of 'unsafePerformIO' is quite /mind-bogglingly unsafe/. It--- unstitches the dependency chain that holds the IO monad together and breaks--- all your ordinary intuitions about IO, sequencing and side effects. Avoid--- it unless you really know what you are doing.------ It is only safe for operations which are genuinely pure (not just--- externally pure) for example reading from an immutable foreign data--- structure. In particular, you should do no memory allocation inside an--- 'unsafeInlinePerformIO' block. This is because an allocation is a constant--- and is likely to be floated out and shared. More generally, any part of any--- IO action that does not depend on a function argument is likely to be--- floated to the top level and have its result shared.------ It is more efficient because in addition to the checks that--- 'unsafeDupablePerformIO' omits, we also inline. Additionally we do not--- pretend that the body is lazy which allows the strictness analyser to see--- the strictness in the body. In turn this allows some re-ordering of--- operations and any corresponding side-effects.------ With GHC it compiles to essentially no code and it exposes the body to--- further inlining.----{-# INLINE unsafeInlinePerformIO #-}-unsafeInlinePerformIO :: IO a -> a-#ifdef __GLASGOW_HASKELL__-unsafeInlinePerformIO (IO m) = case m realWorld# of (# _, r #) -> r-#else-unsafeInlinePerformIO = unsafePerformIO-#endif- -- | Allocate an array which is 16-byte aligned.  Essential for SIMD instructions. mallocForeignPtrArrayAligned :: Storable a => Int -> IO (ForeignPtr a) mallocForeignPtrArrayAligned n = doMalloc undefined@@ -543,7 +512,7 @@ mallocForeignPtrBytesAligned :: Int -> IO (ForeignPtr a) mallocForeignPtrBytesAligned n = do     (ForeignPtr addr contents) <- mallocPlainForeignPtrBytes (n + pad)-    let (Ptr addr') = alignPtr (Ptr addr) 16+    let !(Ptr addr') = alignPtr (Ptr addr) 16     return (ForeignPtr addr' contents)     where pad = 16 - sizeOf (undefined :: Word) 

@@ -1,5 +1,5 @@ name:                carray-version:             0.1.4+version:             0.1.5 synopsis:            A C-compatible array library. description: 		     A C-compatible array library.@@ -37,7 +37,7 @@     build-depends: base < 3, binary    if flag(base4)-    build-depends: base >= 4, syb >= 0.1+    build-depends: base >= 4 && < 5, syb >= 0.1   else     build-depends: base < 4