{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
-- |
-- Module      : Data.Massiv.Array.Manifest.Storable
-- Copyright   : (c) Alexey Kuleshevich 2018-2021
-- License     : BSD3
-- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru>
-- Stability   : experimental
-- Portability : non-portable
--
module Data.Massiv.Array.Manifest.Storable
  ( S (..)
  , Array(..)
  , MArray(..)
  , Storable
  , toStorableVector
  , toStorableMVector
  , fromStorableVector
  , fromStorableMVector
  , withPtr
  , unsafeWithPtr
  , unsafeMallocMArray
  , unsafeArrayToForeignPtr
  , unsafeMArrayToForeignPtr
  , unsafeArrayFromForeignPtr
  , unsafeArrayFromForeignPtr0
  , unsafeMArrayFromForeignPtr
  , unsafeMArrayFromForeignPtr0
  ) where

import Control.DeepSeq (NFData(..), deepseq)
import Control.Exception
import Control.Monad
import Control.Monad.IO.Unlift
import Control.Monad.Primitive
import Data.Massiv.Array.Delayed.Pull (compareArrays, eqArrays)
import Data.Massiv.Array.Manifest.Internal
import Data.Massiv.Array.Manifest.List as A
import Data.Massiv.Array.Mutable
import Data.Massiv.Core.Common
import Data.Massiv.Core.List
import Data.Massiv.Core.Operations
import Data.Massiv.Vector.Stream as S (isteps, steps)
import Data.Primitive.Ptr (setPtr)
import Data.Primitive.ByteArray
import Foreign.ForeignPtr
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array (advancePtr, copyArray)
import Foreign.Ptr
import Foreign.Storable
import GHC.Exts as GHC (IsList(..))
import GHC.ForeignPtr
import Prelude hiding (mapM)
import System.IO.Unsafe (unsafePerformIO)
import Data.Word
import Unsafe.Coerce

import qualified Data.Vector.Generic.Mutable as MVG
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Storable.Mutable as MVS

#include "massiv.h"

-- | Representation for `Storable` elements
data S = S deriving Int -> S -> ShowS
[S] -> ShowS
S -> String
(Int -> S -> ShowS) -> (S -> String) -> ([S] -> ShowS) -> Show S
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [S] -> ShowS
$cshowList :: [S] -> ShowS
show :: S -> String
$cshow :: S -> String
showsPrec :: Int -> S -> ShowS
$cshowsPrec :: Int -> S -> ShowS
Show

data instance Array S ix e = SArray { Array S ix e -> Comp
sComp   :: !Comp
                                    , Array S ix e -> Sz ix
sSize   :: !(Sz ix)
                                    , Array S ix e -> ForeignPtr e
sData   :: {-# UNPACK #-} !(ForeignPtr e)
                                    }

data instance MArray s S ix e = MSArray !(Sz ix) {-# UNPACK #-} !(ForeignPtr e)

instance (Ragged L ix e, Show e, Storable e) => Show (Array S ix e) where
  showsPrec :: Int -> Array S ix e -> ShowS
showsPrec = (Array S ix e -> Array S ix e) -> Int -> Array S ix e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec Array S ix e -> Array S ix e
forall a. a -> a
id
  showList :: [Array S ix e] -> ShowS
showList = [Array S ix e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

instance NFData ix => NFData (Array S ix e) where
  rnf :: Array S ix e -> ()
rnf (SArray c sz _v) = Comp
c Comp -> Sz ix -> Sz ix
forall a b. NFData a => a -> b -> b
`deepseq` Sz ix
sz Sz ix -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` ()
  {-# INLINE rnf #-}

instance NFData ix => NFData (MArray s S ix e) where
  rnf :: MArray s S ix e -> ()
rnf (MSArray sz _mv) = Sz ix
sz Sz ix -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` ()
  {-# INLINE rnf #-}

instance (Storable e, Eq e, Index ix) => Eq (Array S ix e) where
  == :: Array S ix e -> Array S ix e -> Bool
(==) = (e -> e -> Bool) -> Array S ix e -> Array S ix e -> Bool
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool
eqArrays e -> e -> Bool
forall a. Eq a => a -> a -> Bool
(==)
  {-# INLINE (==) #-}

instance (Storable e, Ord e, Index ix) => Ord (Array S ix e) where
  compare :: Array S ix e -> Array S ix e -> Ordering
compare = (e -> e -> Ordering) -> Array S ix e -> Array S ix e -> Ordering
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Ordering)
-> Array r1 ix e1 -> Array r2 ix e2 -> Ordering
compareArrays e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
  {-# INLINE compare #-}

instance Strategy S where
  getComp :: Array S ix e -> Comp
getComp = Array S ix e -> Comp
forall ix e. Array S ix e -> Comp
sComp
  {-# INLINE getComp #-}
  setComp :: Comp -> Array S ix e -> Array S ix e
setComp Comp
c Array S ix e
arr = Array S ix e
R:ArraySixe ix e
arr { sComp :: Comp
sComp = Comp
c }
  {-# INLINE setComp #-}

advanceForeignPtr :: forall e . Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr :: ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp Int
i = ForeignPtr e -> Int -> ForeignPtr e
forall a b. ForeignPtr a -> Int -> ForeignPtr b
plusForeignPtr ForeignPtr e
fp (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* e -> Int
forall a. Storable a => a -> Int
sizeOf (e
forall a. HasCallStack => a
undefined :: e))
{-# INLINE advanceForeignPtr #-}

indexForeignPtr :: Storable e => ForeignPtr e -> Int -> e
indexForeignPtr :: ForeignPtr e -> Int -> e
indexForeignPtr ForeignPtr e
fp Int
i = IO e -> e
forall a. IO a -> a
unsafeInlineIO (IO e -> e) -> IO e -> e
forall a b. (a -> b) -> a -> b
$ ForeignPtr e -> (Ptr e -> IO e) -> IO e
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr e
fp ((Ptr e -> IO e) -> IO e) -> (Ptr e -> IO e) -> IO e
forall a b. (a -> b) -> a -> b
$ \Ptr e
p -> Ptr e -> Int -> IO e
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr e
p Int
i
{-# INLINE indexForeignPtr #-}

instance Storable e => Source S e where
  unsafeLinearIndex :: Array S ix e -> Int -> e
unsafeLinearIndex (SArray _ _sz fp) =
    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp
  {-# INLINE unsafeLinearIndex #-}

  unsafeOuterSlice :: Array S ix e -> Sz (Lower ix) -> Int -> Array S (Lower ix) e
unsafeOuterSlice (SArray c _ fp) Sz (Lower ix)
szL Int
i =
    let k :: Int
k = Sz (Lower ix) -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz (Lower ix)
szL
    in Comp -> Sz (Lower ix) -> ForeignPtr e -> Array S (Lower ix) e
forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray Comp
c Sz (Lower ix)
szL (ForeignPtr e -> Array S (Lower ix) e)
-> ForeignPtr e -> Array S (Lower ix) e
forall a b. (a -> b) -> a -> b
$ ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
k)
  {-# INLINE unsafeOuterSlice #-}

  unsafeLinearSlice :: Int -> Sz1 -> Array S ix e -> Array S Int e
unsafeLinearSlice Int
i Sz1
k (SArray c _ fp) =
    Comp -> Sz1 -> ForeignPtr e -> Array S Int e
forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray Comp
c Sz1
k (ForeignPtr e -> Array S Int e) -> ForeignPtr e -> Array S Int e
forall a b. (a -> b) -> a -> b
$ ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp Int
i
  {-# INLINE unsafeLinearSlice #-}

instance Index ix => Shape S ix where
  maxLinearSize :: Array S ix e -> Maybe Sz1
maxLinearSize = Sz1 -> Maybe Sz1
forall a. a -> Maybe a
Just (Sz1 -> Maybe Sz1)
-> (Array S ix e -> Sz1) -> Array S ix e -> Maybe Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array S ix e -> Int) -> Array S ix e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array S ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount
  {-# INLINE maxLinearSize #-}

instance Size S where
  size :: Array S ix e -> Sz ix
size = Array S ix e -> Sz ix
forall ix e. Array S ix e -> Sz ix
sSize
  {-# INLINE size #-}
  unsafeResize :: Sz ix' -> Array S ix e -> Array S ix' e
unsafeResize !Sz ix'
sz !Array S ix e
arr = Array S ix e
R:ArraySixe ix e
arr { sSize :: Sz ix'
sSize = Sz ix'
sz }
  {-# INLINE unsafeResize #-}


instance Storable e => Manifest S e where

  unsafeLinearIndexM :: Array S ix e -> Int -> e
unsafeLinearIndexM (SArray _ _sz fp) =
    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp
  {-# INLINE unsafeLinearIndexM #-}

  sizeOfMArray :: MArray s S ix e -> Sz ix
sizeOfMArray (MSArray sz _) = Sz ix
sz
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: Sz ix' -> MArray s S ix e -> MArray s S ix' e
unsafeResizeMArray Sz ix'
sz (MSArray _ fp) = Sz ix' -> ForeignPtr e -> MArray s S ix' e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix'
sz ForeignPtr e
fp
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: Int -> Sz1 -> MArray s S ix e -> MVector s S e
unsafeLinearSliceMArray Int
i Sz1
k (MSArray _ fp) = Sz1 -> ForeignPtr e -> MVector s S e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz1
k (ForeignPtr e -> MVector s S e) -> ForeignPtr e -> MVector s S e
forall a b. (a -> b) -> a -> b
$ ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp Int
i
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: Array S ix e -> m (MArray (PrimState m) S ix e)
unsafeThaw (SArray _ sz fp) = MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e))
-> MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ Sz ix -> ForeignPtr e -> MArray (PrimState m) S ix e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix
sz ForeignPtr e
fp
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: Comp -> MArray (PrimState m) S ix e -> m (Array S ix e)
unsafeFreeze Comp
comp (MSArray sz v) = Array S ix e -> m (Array S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Array S ix e -> m (Array S ix e))
-> Array S ix e -> m (Array S ix e)
forall a b. (a -> b) -> a -> b
$ Comp -> Sz ix -> ForeignPtr e -> Array S ix e
forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray Comp
comp Sz ix
sz ForeignPtr e
v
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: Sz ix -> m (MArray (PrimState m) S ix e)
unsafeNew Sz ix
sz = do
    let !n :: Int
n = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz
        dummy :: e
dummy = e
forall a. HasCallStack => a
undefined :: e
        !eSize :: Int
eSize = e -> Int
forall a. Storable a => a -> Int
sizeOf e
dummy
    Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> (Int
forall a. Bounded a => a
maxBound :: Int) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
eSize) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ String -> m ()
forall a. HasCallStack => String -> a
error (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Array size is too big: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Sz ix -> String
forall a. Show a => a -> String
show Sz ix
sz
    IO (MArray (PrimState m) S ix e) -> m (MArray (PrimState m) S ix e)
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO (MArray (PrimState m) S ix e)
 -> m (MArray (PrimState m) S ix e))
-> IO (MArray (PrimState m) S ix e)
-> m (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ do
      ForeignPtr e
fp <- Int -> Int -> IO (ForeignPtr e)
forall a. Int -> Int -> IO (ForeignPtr a)
mallocPlainForeignPtrAlignedBytes (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* e -> Int
forall a. Storable a => a -> Int
sizeOf e
dummy) (e -> Int
forall a. Storable a => a -> Int
alignment e
dummy)
      MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e))
-> MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ Sz ix -> ForeignPtr e -> MArray (PrimState m) S ix e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix
sz ForeignPtr e
fp
  {-# INLINE unsafeNew #-}

  initialize :: MArray (PrimState m) S ix e -> m ()
initialize (MSArray sz fp) =
    IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
      ForeignPtr e -> (Ptr e -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr e
fp ((Ptr e -> IO ()) -> IO ()) -> (Ptr e -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr e
p ->
        Ptr Word8 -> Int -> Word8 -> IO ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
Ptr a -> Int -> a -> m ()
setPtr (Ptr e -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr Ptr e
p) (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* e -> Int
forall a. Storable a => a -> Int
sizeOf (e
forall a. HasCallStack => a
undefined :: e)) (Word8
0 :: Word8)
  {-# INLINE initialize #-}

  unsafeLinearRead :: MArray (PrimState m) S ix e -> Int -> m e
unsafeLinearRead (MSArray _sz fp) Int
o = IO e -> m e
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO e -> m e) -> IO e -> m e
forall a b. (a -> b) -> a -> b
$
    INDEX_CHECK("(Manifest S ix e).unsafeLinearRead", const (toLinearSz _sz), (\_ _ -> unsafeWithForeignPtr fp (`peekElemOff` o))) fp o
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: MArray (PrimState m) S ix e -> Int -> e -> m ()
unsafeLinearWrite (MSArray _sz fp) Int
o e
e = IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
    INDEX_CHECK("(Manifest S ix e).unsafeLinearWrite", const (toLinearSz _sz), (\_ _ -> unsafeWithForeignPtr fp (\p -> pokeElemOff p o e))) fp o
  {-# INLINE unsafeLinearWrite #-}

  unsafeLinearSet :: MArray (PrimState m) S ix e -> Int -> Sz1 -> e -> m ()
unsafeLinearSet (MSArray _ fp) Int
i Sz1
k =
    MVector (PrimState m) e -> e -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> a -> m ()
MVG.basicSet (ForeignPtr e -> Int -> MVector (PrimState m) e
forall a s. Storable a => ForeignPtr a -> Int -> MVector s a
MVS.unsafeFromForeignPtr0 (ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp Int
i) (Sz1 -> Int
forall ix. Sz ix -> ix
unSz Sz1
k))
  {-# INLINE unsafeLinearSet #-}

  unsafeLinearCopy :: MArray (PrimState m) S ix' e
-> Int -> MArray (PrimState m) S ix e -> Int -> Sz1 -> m ()
unsafeLinearCopy (MSArray _ fpFrom) Int
iFrom (MSArray _ fpTo) Int
iTo (Sz Int
k) = do
    IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
      ForeignPtr e -> (Ptr e -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr e
fpFrom ((Ptr e -> IO ()) -> IO ()) -> (Ptr e -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ Ptr e
ptrFrom ->
        ForeignPtr e -> (Ptr e -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr e
fpTo ((Ptr e -> IO ()) -> IO ()) -> (Ptr e -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ Ptr e
ptrTo -> do
          let ptrFrom' :: Ptr e
ptrFrom' = Ptr e -> Int -> Ptr e
forall a. Storable a => Ptr a -> Int -> Ptr a
advancePtr Ptr e
ptrFrom Int
iFrom
              ptrTo' :: Ptr e
ptrTo' = Ptr e -> Int -> Ptr e
forall a. Storable a => Ptr a -> Int -> Ptr a
advancePtr Ptr e
ptrTo Int
iTo
          Ptr e -> Ptr e -> Int -> IO ()
forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray Ptr e
ptrTo' Ptr e
ptrFrom' Int
k
  {-# INLINE unsafeLinearCopy #-}

  unsafeArrayLinearCopy :: Array S ix' e
-> Int -> MArray (PrimState m) S ix e -> Int -> Sz1 -> m ()
unsafeArrayLinearCopy Array S ix' e
arrFrom Int
iFrom MArray (PrimState m) S ix e
marrTo Int
iTo Sz1
sz = do
    MArray (PrimState m) S ix' e
marrFrom <- Array S ix' e -> m (MArray (PrimState m) S ix' e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Array r ix e -> m (MArray (PrimState m) r ix e)
unsafeThaw Array S ix' e
arrFrom
    MArray (PrimState m) S ix' e
-> Int -> MArray (PrimState m) S ix e -> Int -> Sz1 -> m ()
forall r e ix' ix (m :: * -> *).
(Manifest r e, Index ix', Index ix, PrimMonad m) =>
MArray (PrimState m) r ix' e
-> Int -> MArray (PrimState m) r ix e -> Int -> Sz1 -> m ()
unsafeLinearCopy MArray (PrimState m) S ix' e
marrFrom Int
iFrom MArray (PrimState m) S ix e
marrTo Int
iTo Sz1
sz
  {-# INLINE unsafeArrayLinearCopy #-}

  unsafeLinearShrink :: MArray (PrimState m) S ix e
-> Sz ix -> m (MArray (PrimState m) S ix e)
unsafeLinearShrink marr :: MArray (PrimState m) S ix e
marr@(MSArray _ fp@(ForeignPtr _ fpc)) Sz ix
sz = do
    let shrinkMBA :: MutableByteArray RealWorld -> IO ()
        shrinkMBA :: MutableByteArray RealWorld -> IO ()
shrinkMBA MutableByteArray RealWorld
mba = MutableByteArray (PrimState IO) -> Int -> IO ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Int -> m ()
shrinkMutableByteArray MutableByteArray RealWorld
MutableByteArray (PrimState IO)
mba (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* e -> Int
forall a. Storable a => a -> Int
sizeOf (e
forall a. HasCallStack => a
undefined :: e))
        {-# INLINE shrinkMBA #-}
    case ForeignPtrContents
fpc of
      MallocPtr MutableByteArray# RealWorld
mba# IORef Finalizers
_ -> do
        IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MutableByteArray RealWorld -> IO ()
shrinkMBA (MutableByteArray# RealWorld -> MutableByteArray RealWorld
forall s. MutableByteArray# s -> MutableByteArray s
MutableByteArray MutableByteArray# RealWorld
mba#)
        MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e))
-> MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ Sz ix -> ForeignPtr e -> MArray (PrimState m) S ix e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix
sz ForeignPtr e
fp
      PlainPtr MutableByteArray# RealWorld
mba# -> do
        IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MutableByteArray RealWorld -> IO ()
shrinkMBA (MutableByteArray# RealWorld -> MutableByteArray RealWorld
forall s. MutableByteArray# s -> MutableByteArray s
MutableByteArray MutableByteArray# RealWorld
mba#)
        MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e))
-> MArray (PrimState m) S ix e -> m (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ Sz ix -> ForeignPtr e -> MArray (PrimState m) S ix e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix
sz ForeignPtr e
fp
      ForeignPtrContents
_ -> MArray (PrimState m) S ix e
-> Sz ix -> m (MArray (PrimState m) S ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
MArray (PrimState m) r ix e
-> Sz ix -> m (MArray (PrimState m) r ix e)
unsafeDefaultLinearShrink MArray (PrimState m) S ix e
marr Sz ix
sz
  {-# INLINE unsafeLinearShrink #-}

instance (Index ix, Storable e) => Load S ix e where
  makeArrayLinear :: Comp -> Sz ix -> (Int -> e) -> Array S ix e
makeArrayLinear !Comp
comp !Sz ix
sz Int -> e
f = IO (Array S ix e) -> Array S ix e
forall a. IO a -> a
unsafePerformIO (IO (Array S ix e) -> Array S ix e)
-> IO (Array S ix e) -> Array S ix e
forall a b. (a -> b) -> a -> b
$ Comp -> Sz ix -> (Int -> IO e) -> IO (Array S ix e)
forall r ix e (m :: * -> *).
(MonadUnliftIO m, Manifest r e, Index ix) =>
Comp -> Sz ix -> (Int -> m e) -> m (Array r ix e)
generateArrayLinear Comp
comp Sz ix
sz (e -> IO e
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> IO e) -> (Int -> e) -> Int -> IO e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> e
f)
  {-# INLINE makeArrayLinear #-}

  replicate :: Comp -> Sz ix -> e -> Array S ix e
replicate Comp
comp !Sz ix
sz !e
e = (forall s. ST s (Array S ix e)) -> Array S ix e
forall a. (forall s. ST s a) -> a
runST (Sz ix -> e -> ST s (MArray (PrimState (ST s)) S ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
newMArray Sz ix
sz e
e ST s (MArray s S ix e)
-> (MArray s S ix e -> ST s (Array S ix e)) -> ST s (Array S ix e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Comp -> MArray (PrimState (ST s)) S ix e -> ST s (Array S ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}

  iterArrayLinearST_ :: Scheduler s () -> Array S ix e -> (Int -> e -> ST s ()) -> ST s ()
iterArrayLinearST_ !Scheduler s ()
scheduler !Array S ix e
arr =
    Scheduler s ()
-> Int -> (Int -> e) -> (Int -> e -> ST s ()) -> ST s ()
forall s (m :: * -> *) b.
MonadPrimBase s m =>
Scheduler s () -> Int -> (Int -> b) -> (Int -> b -> m ()) -> m ()
splitLinearlyWith_ Scheduler s ()
scheduler (Array S ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount Array S ix e
arr) (Array S ix e -> Int -> e
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array S ix e
arr)
  {-# INLINE iterArrayLinearST_ #-}

instance (Index ix, Storable e) => StrideLoad S ix e

instance (Index ix, Storable e) => Stream S ix e where
  toStream :: Array S ix e -> Steps Id e
toStream = Array S ix e -> Steps Id e
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m e
S.steps
  {-# INLINE toStream #-}
  toStreamIx :: Array S ix e -> Steps Id (ix, e)
toStreamIx = Array S ix e -> Steps Id (ix, e)
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m (ix, e)
S.isteps
  {-# INLINE toStreamIx #-}


instance (Storable e, Num e) => FoldNumeric S e where
  unsafeDotProduct :: Array S ix e -> Array S ix e -> e
unsafeDotProduct = Array S ix e -> Array S ix e -> e
forall e ix r.
(Num e, Index ix, Source r e) =>
Array r ix e -> Array r ix e -> e
defaultUnsafeDotProduct
  {-# INLINE unsafeDotProduct #-}
  powerSumArray :: Array S ix e -> Int -> e
powerSumArray = Array S ix e -> Int -> e
forall ix r e.
(Index ix, Source r e, Num e) =>
Array r ix e -> Int -> e
defaultPowerSumArray
  {-# INLINE powerSumArray #-}
  foldArray :: (e -> e -> e) -> e -> Array S ix e -> e
foldArray = (e -> e -> e) -> e -> Array S ix e -> e
forall ix r e.
(Index ix, Source r e) =>
(e -> e -> e) -> e -> Array r ix e -> e
defaultFoldArray
  {-# INLINE foldArray #-}

instance (Storable e, Num e) => Numeric S e where
  unsafeLiftArray :: (e -> e) -> Array S ix e -> Array S ix e
unsafeLiftArray = (e -> e) -> Array S ix e -> Array S ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e) -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray
  {-# INLINE unsafeLiftArray #-}
  unsafeLiftArray2 :: (e -> e -> e) -> Array S ix e -> Array S ix e -> Array S ix e
unsafeLiftArray2 = (e -> e -> e) -> Array S ix e -> Array S ix e -> Array S ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e -> e) -> Array r ix e -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray2
  {-# INLINE unsafeLiftArray2 #-}

instance (Storable e, Floating e) => NumericFloat S e


instance (Storable e, IsList (Array L ix e), Ragged L ix e) => IsList (Array S ix e) where
  type Item (Array S ix e) = Item (Array L ix e)
  fromList :: [Item (Array S ix e)] -> Array S ix e
fromList = Comp -> [ListItem ix e] -> Array S ix e
forall r ix e.
(HasCallStack, Ragged L ix e, Manifest r e) =>
Comp -> [ListItem ix e] -> Array r ix e
A.fromLists' Comp
Seq
  {-# INLINE fromList #-}
  toList :: Array S ix e -> [Item (Array S ix e)]
toList = Array L ix e -> [ListItem ix e]
forall l. IsList l => l -> [Item l]
GHC.toList (Array L ix e -> [ListItem ix e])
-> (Array S ix e -> Array L ix e)
-> Array S ix e
-> [ListItem ix e]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array S ix e -> Array L ix e
forall ix e r.
(Ragged L ix e, Shape r ix, Source r e) =>
Array r ix e -> Array L ix e
toListArray
  {-# INLINE toList #-}

-- | A pointer to the beginning of the storable array. It is unsafe since, if mutated, it can break
-- referential transparency.
--
-- @since 0.1.3
unsafeWithPtr :: MonadUnliftIO m => Array S ix e -> (Ptr e -> m b) -> m b
unsafeWithPtr :: Array S ix e -> (Ptr e -> m b) -> m b
unsafeWithPtr Array S ix e
arr Ptr e -> m b
f = ((forall a. m a -> IO a) -> IO b) -> m b
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. m a -> IO a) -> IO b) -> m b
withRunInIO (((forall a. m a -> IO a) -> IO b) -> m b)
-> ((forall a. m a -> IO a) -> IO b) -> m b
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> IO a
run -> ForeignPtr e -> (Ptr e -> IO b) -> IO b
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr (Array S ix e -> ForeignPtr e
forall ix e. Array S ix e -> ForeignPtr e
sData Array S ix e
arr) (m b -> IO b
forall a. m a -> IO a
run (m b -> IO b) -> (Ptr e -> m b) -> Ptr e -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr e -> m b
f)
{-# INLINE unsafeWithPtr #-}


-- | A pointer to the beginning of the mutable array.
--
-- @since 0.1.3
withPtr :: MonadUnliftIO m => MArray RealWorld S ix e -> (Ptr e -> m b) -> m b
withPtr :: MArray RealWorld S ix e -> (Ptr e -> m b) -> m b
withPtr (MSArray _ fp) Ptr e -> m b
f = ((forall a. m a -> IO a) -> IO b) -> m b
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. m a -> IO a) -> IO b) -> m b
withRunInIO (((forall a. m a -> IO a) -> IO b) -> m b)
-> ((forall a. m a -> IO a) -> IO b) -> m b
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> IO a
run -> ForeignPtr e -> (Ptr e -> IO b) -> IO b
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr ForeignPtr e
fp (m b -> IO b
forall a. m a -> IO a
run (m b -> IO b) -> (Ptr e -> m b) -> Ptr e -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr e -> m b
f)
{-# INLINE withPtr #-}


-- | /O(1)/ - Unwrap storable array and pull out the underlying storable vector.
--
-- @since 0.2.1
toStorableVector :: Index ix => Array S ix e -> VS.Vector e
toStorableVector :: Array S ix e -> Vector e
toStorableVector Array S ix e
arr =
  Vector Word -> Vector e
forall a b. a -> b
unsafeCoerce (Vector Word -> Vector e) -> Vector Word -> Vector e
forall a b. (a -> b) -> a -> b
$ -- this hack is needed to workaround the redundant Storable constraint
                 -- see haskell/vector#394
  ForeignPtr Word -> Int -> Vector Word
forall a. Storable a => ForeignPtr a -> Int -> Vector a
VS.unsafeFromForeignPtr0 (ForeignPtr e -> ForeignPtr Word
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr (Array S ix e -> ForeignPtr e
forall ix e. Array S ix e -> ForeignPtr e
sData Array S ix e
arr) :: ForeignPtr Word) (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem (Array S ix e -> Sz ix
forall ix e. Array S ix e -> Sz ix
sSize Array S ix e
arr))
{-# INLINE toStorableVector #-}


-- | /O(1)/ - Unwrap storable mutable array and pull out the underlying storable mutable vector.
--
-- @since 0.2.1
toStorableMVector :: Index ix => MArray s S ix e -> VS.MVector s e
toStorableMVector :: MArray s S ix e -> MVector s e
toStorableMVector (MSArray sz fp) = Int -> ForeignPtr e -> MVector s e
forall s a. Int -> ForeignPtr a -> MVector s a
MVS.MVector (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz) ForeignPtr e
fp
{-# INLINE toStorableMVector #-}

-- | /O(1)/ - Cast a storable vector to a storable array.
--
-- @since 0.5.0
fromStorableVector :: Comp -> VS.Vector e -> Vector S e
fromStorableVector :: Comp -> Vector e -> Vector S e
fromStorableVector Comp
comp Vector e
v =
  -- unasfeCoerce hack below is needed to workaround the redundant Storable
  -- constraint see haskell/vector#394
  case Vector Word -> (ForeignPtr Word, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int)
VS.unsafeToForeignPtr0 (Vector e -> Vector Word
forall a b. a -> b
unsafeCoerce Vector e
v :: VS.Vector Word) of
    (ForeignPtr Word
fp, Int
k) -> SArray :: forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray {sComp :: Comp
sComp = Comp
comp, sSize :: Sz1
sSize = Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
k, sData :: ForeignPtr e
sData = ForeignPtr Word -> ForeignPtr e
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr Word
fp}
{-# INLINE fromStorableVector #-}

-- | /O(1)/ - Cast a mutable storable vector to a mutable storable array.
--
-- @since 0.5.0
fromStorableMVector :: MVS.MVector s e -> MVector s S e
fromStorableMVector :: MVector s e -> MVector s S e
fromStorableMVector (MVS.MVector Int
n ForeignPtr e
fp) = Sz1 -> ForeignPtr e -> MVector s S e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
n) ForeignPtr e
fp
{-# INLINE fromStorableMVector #-}


-- | /O(1)/ - Yield the underlying `ForeignPtr` together with its length.
--
-- @since 0.3.0
unsafeArrayToForeignPtr :: Index ix => Array S ix e -> (ForeignPtr e, Int)
unsafeArrayToForeignPtr :: Array S ix e -> (ForeignPtr e, Int)
unsafeArrayToForeignPtr (SArray _ sz fp) = (ForeignPtr e
fp, Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz)
{-# INLINE unsafeArrayToForeignPtr #-}

-- | /O(1)/ - Yield the underlying `ForeignPtr` together with its length.
--
-- @since 0.3.0
unsafeMArrayToForeignPtr :: Index ix => MArray s S ix e -> (ForeignPtr e, Int)
unsafeMArrayToForeignPtr :: MArray s S ix e -> (ForeignPtr e, Int)
unsafeMArrayToForeignPtr (MSArray sz fp) = (ForeignPtr e
fp, Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz)
{-# INLINE unsafeMArrayToForeignPtr #-}

-- | /O(1)/ - Wrap a `ForeignPtr` and it's size into a pure storable array.
--
-- @since 0.3.0
unsafeArrayFromForeignPtr0 :: Comp -> ForeignPtr e -> Sz1 -> Vector S e
unsafeArrayFromForeignPtr0 :: Comp -> ForeignPtr e -> Sz1 -> Vector S e
unsafeArrayFromForeignPtr0 Comp
comp ForeignPtr e
fp Sz1
sz = SArray :: forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray {sComp :: Comp
sComp = Comp
comp, sSize :: Sz1
sSize = Sz1
sz, sData :: ForeignPtr e
sData = ForeignPtr e
fp}
{-# INLINE unsafeArrayFromForeignPtr0 #-}

-- | /O(1)/ - Wrap a `ForeignPtr`, an offset and it's size into a pure storable array.
--
-- @since 0.3.0
unsafeArrayFromForeignPtr :: Storable e => Comp -> ForeignPtr e -> Int -> Sz1 -> Array S Ix1 e
unsafeArrayFromForeignPtr :: Comp -> ForeignPtr e -> Int -> Sz1 -> Array S Int e
unsafeArrayFromForeignPtr Comp
comp ForeignPtr e
ptr Int
offset Sz1
sz =
  SArray :: forall ix e. Comp -> Sz ix -> ForeignPtr e -> Array S ix e
SArray {sComp :: Comp
sComp = Comp
comp, sSize :: Sz1
sSize = Sz1
sz, sData :: ForeignPtr e
sData = ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
ptr Int
offset}
{-# INLINE unsafeArrayFromForeignPtr #-}


-- | /O(1)/ - Wrap a `ForeignPtr` and it's size into a mutable storable array. It is still safe to
-- modify the pointer, unless the array gets frozen prior to modification.
--
-- @since 0.3.0
unsafeMArrayFromForeignPtr0 :: ForeignPtr e -> Sz1 -> MArray s S Ix1 e
unsafeMArrayFromForeignPtr0 :: ForeignPtr e -> Sz1 -> MArray s S Int e
unsafeMArrayFromForeignPtr0 ForeignPtr e
fp Sz1
sz = Sz1 -> ForeignPtr e -> MArray s S Int e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz1
sz ForeignPtr e
fp
{-# INLINE unsafeMArrayFromForeignPtr0 #-}


-- | /O(1)/ - Wrap a `ForeignPtr`, an offset and it's size into a mutable storable array. It is
-- still safe to modify the pointer, unless the array gets frozen prior to modification.
--
-- @since 0.3.0
unsafeMArrayFromForeignPtr :: Storable e => ForeignPtr e -> Int -> Sz1 -> MArray s S Ix1 e
unsafeMArrayFromForeignPtr :: ForeignPtr e -> Int -> Sz1 -> MArray s S Int e
unsafeMArrayFromForeignPtr ForeignPtr e
fp Int
offset Sz1
sz = Sz1 -> ForeignPtr e -> MArray s S Int e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz1
sz (ForeignPtr e -> Int -> ForeignPtr e
forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e
advanceForeignPtr ForeignPtr e
fp Int
offset)
{-# INLINE unsafeMArrayFromForeignPtr #-}


-- | Allocate memory using @malloc@ on C heap, instead of on Haskell heap. Memory is left
-- uninitialized
--
-- @since 0.5.9
unsafeMallocMArray ::
     forall ix e m. (Index ix, Storable e, PrimMonad m)
  => Sz ix
  -> m (MArray (PrimState m) S ix e)
unsafeMallocMArray :: Sz ix -> m (MArray (PrimState m) S ix e)
unsafeMallocMArray Sz ix
sz = IO (MArray (PrimState m) S ix e) -> m (MArray (PrimState m) S ix e)
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO (MArray (PrimState m) S ix e)
 -> m (MArray (PrimState m) S ix e))
-> IO (MArray (PrimState m) S ix e)
-> m (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ do
  let n :: Int
n = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz
  ForeignPtr e
foreignPtr <- IO (ForeignPtr e) -> IO (ForeignPtr e)
forall a. IO a -> IO a
mask_ (IO (ForeignPtr e) -> IO (ForeignPtr e))
-> IO (ForeignPtr e) -> IO (ForeignPtr e)
forall a b. (a -> b) -> a -> b
$ do
    Ptr e
ptr <- Int -> IO (Ptr e)
forall a. Int -> IO (Ptr a)
mallocBytes (e -> Int
forall a. Storable a => a -> Int
sizeOf (e
forall a. HasCallStack => a
undefined :: e) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)
    FinalizerPtr e -> Ptr e -> IO (ForeignPtr e)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr e
forall a. FinalizerPtr a
finalizerFree Ptr e
ptr
  MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e))
-> MArray (PrimState m) S ix e -> IO (MArray (PrimState m) S ix e)
forall a b. (a -> b) -> a -> b
$ Sz ix -> ForeignPtr e -> MArray (PrimState m) S ix e
forall s ix e. Sz ix -> ForeignPtr e -> MArray s S ix e
MSArray Sz ix
sz ForeignPtr e
foreignPtr
{-# INLINE unsafeMallocMArray #-}


#if !MIN_VERSION_base(4,15,0)
-- | A compatibility wrapper for 'GHC.ForeignPtr.unsafeWithForeignPtr' provided
-- by GHC 9.0.1 and later.
--
-- Only to be used when the continuation is known not to
-- unconditionally diverge lest unsoundness can result.
unsafeWithForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
unsafeWithForeignPtr = ForeignPtr a -> (Ptr a -> IO b) -> IO b
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr
#endif