base-compat-batteries-0.13.1: base-compat with extra batteries
Safe HaskellSafe-Inferred
LanguageHaskell2010

Foreign.Marshal.Compat

Documentation

new :: Storable a => a -> IO (Ptr a) #

void :: IO a -> IO () #

alloca :: Storable a => (Ptr a -> IO b) -> IO b #

allocaBytes :: Int -> (Ptr a -> IO b) -> IO b #

allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b #

calloc :: Storable a => IO (Ptr a) #

callocBytes :: Int -> IO (Ptr a) #

free :: Ptr a -> IO () #

malloc :: Storable a => IO (Ptr a) #

mallocBytes :: Int -> IO (Ptr a) #

realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b) #

reallocBytes :: Ptr a -> Int -> IO (Ptr a) #

advancePtr :: Storable a => Ptr a -> Int -> Ptr a #

allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b #

allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b #

callocArray :: Storable a => Int -> IO (Ptr a) #

callocArray0 :: Storable a => Int -> IO (Ptr a) #

copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO () #

lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int #

mallocArray :: Storable a => Int -> IO (Ptr a) #

mallocArray0 :: Storable a => Int -> IO (Ptr a) #

moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO () #

newArray :: Storable a => [a] -> IO (Ptr a) #

newArray0 :: Storable a => a -> [a] -> IO (Ptr a) #

peekArray :: Storable a => Int -> Ptr a -> IO [a] #

peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a] #

pokeArray :: Storable a => Ptr a -> [a] -> IO () #

pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO () #

reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a) #

reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a) #

withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b #

withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b #

withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b #

withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b #

throwIf :: (a -> Bool) -> (a -> String) -> IO a -> IO a #

throwIfNeg :: (Ord a, Num a) => (a -> String) -> IO a -> IO a #

throwIfNeg_ :: (Ord a, Num a) => (a -> String) -> IO a -> IO () #

throwIfNull :: String -> IO (Ptr a) -> IO (Ptr a) #

throwIf_ :: (a -> Bool) -> (a -> String) -> IO a -> IO () #

freePool :: Pool -> IO () #

pooledMalloc :: Storable a => Pool -> IO (Ptr a) #

pooledNew :: Storable a => Pool -> a -> IO (Ptr a) #

pooledNewArray :: Storable a => Pool -> [a] -> IO (Ptr a) #

pooledNewArray0 :: Storable a => Pool -> a -> [a] -> IO (Ptr a) #

pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a) #

pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a) #

pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a) #

pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a) #

withPool :: (Pool -> IO b) -> IO b #

copyBytes :: Ptr a -> Ptr a -> Int -> IO () #

fillBytes :: Ptr a -> Word8 -> Int -> IO () #

fromBool :: Num a => Bool -> a #

maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b) #

maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b) #

maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c #

moveBytes :: Ptr a -> Ptr a -> Int -> IO () #

toBool :: (Eq a, Num a) => a -> Bool #

with :: Storable a => a -> (Ptr a -> IO b) -> IO b #

withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res #

data Pool #