Foreign.Marshal.Array.Compat · base-compat-0.14.1

valuecallocArray :: Storable a => Int -> IO (Ptr a)

#

Like mallocArray, but allocated memory is filled with bytes of value zero.

valuecallocArray0 :: Storable a => Int -> IO (Ptr a)

#

Like callocArray0, but allocated memory is filled with bytes of value zero.

valueadvancePtr :: Storable a => Ptr a -> Int -> Ptr a

#

Advance a pointer into an array by the given number of elements

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

#

Temporarily allocate space for the given number of elements (like alloca, but for multiple elements).

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

#

Like allocaArray, but add an extra position to hold a special termination element.

valuecopyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()

#

Copy the given number of elements from the second array (source) into the first array (destination); the copied areas may not overlap

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

#

Return the number of elements in an array, excluding the terminator

valuemallocArray :: Storable a => Int -> IO (Ptr a)

#

Allocate storage for the given number of elements of a storable type (like malloc, but for multiple elements).

valuemallocArray0 :: Storable a => Int -> IO (Ptr a)

#

Like mallocArray, but add an extra position to hold a special termination element.

valuemoveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()

#

Copy the given number of elements from the second array (source) into the first array (destination); the copied areas may overlap

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

#

Write a list of storable elements into a newly allocated, consecutive sequence of storable values (like new, but for multiple elements).

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

#

Write a list of storable elements into a newly allocated, consecutive sequence of storable values, where the end is fixed by the given end marker

valuepeekArray :: Storable a => Int -> Ptr a -> IO [a]

#

Convert an array of given length into a Haskell list. The implementation is tail-recursive and so uses constant stack space.

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

#

Convert an array terminated by the given end marker into a Haskell list

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

#

Write the list elements consecutive into memory

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

#

Write the list elements consecutive into memory and terminate them with the given marker element

valuereallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)

#

Adjust the size of an array

valuereallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)

#

Adjust the size of an array including an extra position for the end marker.

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

#

Temporarily store a list of storable values in memory (like with, but for multiple elements).

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

#

Like withArray, but a terminator indicates where the array ends

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

#

Like withArray, but the action gets the number of values as an additional parameter

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

#

Like withArrayLen, but a terminator indicates where the array ends