| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
UnliftIO.Foreign
Contents
- Re-exported modules
- Unlifted Foreign.C.String
- Unlifted Foreign.C.Error
- Unlifted Foreign.Ptr
- Unlifted Foreign.ForeignPtr
- Unlifted Foreign.StablePtr
- Unlifted Foreign.Storable
- Unlifted Foreign.Marshal.Alloc
- Unlifted Foreign.Marshal.Array
- Unlifted Foreign.Marshal.Error
- Unlifted Foreign.Marshal.Pool
- Unlifted Foreign.Marshal.Utils
Description
Unlifted Foreign .
Since: 0.2.5.0
Synopsis
- module Data.Bits
- module Data.Int
- module Data.Word
- module Foreign.C.Types
- type CString = Ptr CChar
- type CStringLen = ( Ptr CChar , Int )
- peekCString :: MonadIO m => CString -> m String
- peekCStringLen :: MonadIO m => CStringLen -> m String
- newCString :: MonadIO m => String -> m CString
- newCStringLen :: MonadIO m => String -> m CStringLen
- withCString :: MonadUnliftIO m => String -> ( CString -> m a) -> m a
- withCStringLen :: MonadUnliftIO m => String -> ( CStringLen -> m a) -> m a
- charIsRepresentable :: Char -> IO Bool
- castCharToCChar :: Char -> CChar
- castCCharToChar :: CChar -> Char
- castCharToCUChar :: Char -> CUChar
- castCUCharToChar :: CUChar -> Char
- castCharToCSChar :: Char -> CSChar
- castCSCharToChar :: CSChar -> Char
- peekCAString :: MonadIO m => CString -> m String
- peekCAStringLen :: MonadIO m => CStringLen -> m String
- newCAString :: MonadIO m => String -> m CString
- newCAStringLen :: MonadIO m => String -> m CStringLen
- withCAString :: MonadUnliftIO m => String -> ( CString -> m a) -> m a
- withCAStringLen :: MonadUnliftIO m => String -> ( CStringLen -> m a) -> m a
- type CWString = Ptr CWchar
- type CWStringLen = ( Ptr CWchar , Int )
- peekCWString :: MonadIO m => CWString -> m String
- peekCWStringLen :: MonadIO m => CWStringLen -> m String
- newCWString :: MonadIO m => String -> m CWString
- newCWStringLen :: MonadIO m => String -> m CWStringLen
- withCWString :: MonadUnliftIO m => String -> ( CWString -> m a) -> m a
- withCWStringLen :: MonadUnliftIO m => String -> ( CWStringLen -> m a) -> m a
- newtype Errno = Errno CInt
- eOK :: Errno
- e2BIG :: Errno
- eACCES :: Errno
- eADDRINUSE :: Errno
- eADDRNOTAVAIL :: Errno
- eADV :: Errno
- eAFNOSUPPORT :: Errno
- eAGAIN :: Errno
- eALREADY :: Errno
- eBADF :: Errno
- eBADMSG :: Errno
- eBADRPC :: Errno
- eBUSY :: Errno
- eCHILD :: Errno
- eCOMM :: Errno
- eCONNABORTED :: Errno
- eCONNREFUSED :: Errno
- eCONNRESET :: Errno
- eDEADLK :: Errno
- eDESTADDRREQ :: Errno
- eDIRTY :: Errno
- eDOM :: Errno
- eDQUOT :: Errno
- eEXIST :: Errno
- eFAULT :: Errno
- eFBIG :: Errno
- eFTYPE :: Errno
- eHOSTDOWN :: Errno
- eHOSTUNREACH :: Errno
- eIDRM :: Errno
- eILSEQ :: Errno
- eINPROGRESS :: Errno
- eINTR :: Errno
- eINVAL :: Errno
- eIO :: Errno
- eISCONN :: Errno
- eISDIR :: Errno
- eLOOP :: Errno
- eMFILE :: Errno
- eMLINK :: Errno
- eMSGSIZE :: Errno
- eMULTIHOP :: Errno
- eNAMETOOLONG :: Errno
- eNETDOWN :: Errno
- eNETRESET :: Errno
- eNETUNREACH :: Errno
- eNFILE :: Errno
- eNOBUFS :: Errno
- eNODATA :: Errno
- eNODEV :: Errno
- eNOENT :: Errno
- eNOEXEC :: Errno
- eNOLCK :: Errno
- eNOLINK :: Errno
- eNOMEM :: Errno
- eNOMSG :: Errno
- eNONET :: Errno
- eNOPROTOOPT :: Errno
- eNOSPC :: Errno
- eNOSR :: Errno
- eNOSTR :: Errno
- eNOSYS :: Errno
- eNOTBLK :: Errno
- eNOTCONN :: Errno
- eNOTDIR :: Errno
- eNOTEMPTY :: Errno
- eNOTSOCK :: Errno
- eNOTSUP :: Errno
- eNOTTY :: Errno
- eNXIO :: Errno
- eOPNOTSUPP :: Errno
- ePERM :: Errno
- ePFNOSUPPORT :: Errno
- ePIPE :: Errno
- ePROCLIM :: Errno
- ePROCUNAVAIL :: Errno
- ePROGMISMATCH :: Errno
- ePROGUNAVAIL :: Errno
- ePROTO :: Errno
- ePROTONOSUPPORT :: Errno
- ePROTOTYPE :: Errno
- eRANGE :: Errno
- eREMCHG :: Errno
- eREMOTE :: Errno
- eROFS :: Errno
- eRPCMISMATCH :: Errno
- eRREMOTE :: Errno
- eSHUTDOWN :: Errno
- eSOCKTNOSUPPORT :: Errno
- eSPIPE :: Errno
- eSRCH :: Errno
- eSRMNT :: Errno
- eSTALE :: Errno
- eTIME :: Errno
- eTIMEDOUT :: Errno
- eTOOMANYREFS :: Errno
- eTXTBSY :: Errno
- eUSERS :: Errno
- eWOULDBLOCK :: Errno
- eXDEV :: Errno
- isValidErrno :: Errno -> Bool
- getErrno :: MonadIO m => m Errno
- resetErrno :: MonadIO m => m ()
- errnoToIOError :: String -> Errno -> Maybe Handle -> Maybe String -> IOError
- throwErrno :: MonadIO m => String -> m a
- throwErrnoIf :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m a
- throwErrnoIf_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m ()
- throwErrnoIfRetry :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m a
- throwErrnoIfRetry_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m ()
- throwErrnoIfMinus1 :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a
- throwErrnoIfMinus1_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m ()
- throwErrnoIfMinus1Retry :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a
- throwErrnoIfMinus1Retry_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m ()
- throwErrnoIfNull :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a)
- throwErrnoIfNullRetry :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a)
- throwErrnoIfRetryMayBlock :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m b -> m a
- throwErrnoIfRetryMayBlock_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m b -> m ()
- throwErrnoIfMinus1RetryMayBlock :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m a
- throwErrnoIfMinus1RetryMayBlock_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m ()
- throwErrnoIfNullRetryMayBlock :: MonadUnliftIO m => String -> m ( Ptr a) -> m b -> m ( Ptr a)
- throwErrnoPath :: MonadIO m => String -> FilePath -> m a
- throwErrnoPathIf :: MonadUnliftIO m => (a -> Bool ) -> String -> FilePath -> m a -> m a
- throwErrnoPathIf_ :: MonadUnliftIO m => (a -> Bool ) -> String -> FilePath -> m a -> m ()
- throwErrnoPathIfNull :: MonadUnliftIO m => String -> FilePath -> m ( Ptr a) -> m ( Ptr a)
- throwErrnoPathIfMinus1 :: ( MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m a
- throwErrnoPathIfMinus1_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m ()
- data Ptr a
- nullPtr :: Ptr a
- castPtr :: Ptr a -> Ptr b
- plusPtr :: Ptr a -> Int -> Ptr b
- alignPtr :: Ptr a -> Int -> Ptr a
- minusPtr :: Ptr a -> Ptr b -> Int
- data FunPtr a
- nullFunPtr :: FunPtr a
- castFunPtr :: FunPtr a -> FunPtr b
- castFunPtrToPtr :: FunPtr a -> Ptr b
- castPtrToFunPtr :: Ptr a -> FunPtr b
- freeHaskellFunPtr :: MonadIO m => FunPtr a -> m ()
- newtype IntPtr = IntPtr Int
- ptrToIntPtr :: Ptr a -> IntPtr
- intPtrToPtr :: IntPtr -> Ptr a
- newtype WordPtr = WordPtr Word
- ptrToWordPtr :: Ptr a -> WordPtr
- wordPtrToPtr :: WordPtr -> Ptr a
- data ForeignPtr a
- type FinalizerPtr a = FunPtr ( Ptr a -> IO ())
- type FinalizerEnvPtr env a = FunPtr ( Ptr env -> Ptr a -> IO ())
- newForeignPtr :: MonadIO m => FinalizerPtr a -> Ptr a -> m ( ForeignPtr a)
- newForeignPtr_ :: MonadIO m => Ptr a -> m ( ForeignPtr a)
- addForeignPtrFinalizer :: MonadIO m => FinalizerPtr a -> ForeignPtr a -> m ()
- newForeignPtrEnv :: MonadIO m => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> m ( ForeignPtr a)
- addForeignPtrFinalizerEnv :: MonadIO m => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> m ()
- withForeignPtr :: MonadUnliftIO m => ForeignPtr a -> ( Ptr a -> m b) -> m b
- finalizeForeignPtr :: MonadIO m => ForeignPtr a -> m ()
- touchForeignPtr :: MonadIO m => ForeignPtr a -> m ()
- castForeignPtr :: ForeignPtr a -> ForeignPtr b
- plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
- mallocForeignPtr :: ( MonadIO m, Storable a) => m ( ForeignPtr a)
- mallocForeignPtrBytes :: MonadIO m => Int -> m ( ForeignPtr a)
- mallocForeignPtrArray :: ( MonadIO m, Storable a) => Int -> m ( ForeignPtr a)
- mallocForeignPtrArray0 :: ( MonadIO m, Storable a) => Int -> m ( ForeignPtr a)
- newGHCForeignPtr :: MonadUnliftIO m => Ptr a -> m () -> m ( ForeignPtr a)
- addGHCForeignPtrFinalizer :: MonadUnliftIO m => ForeignPtr a -> m () -> m ()
- unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
- data StablePtr a
- newStablePtr :: MonadIO m => a -> m ( StablePtr a)
- deRefStablePtr :: MonadIO m => StablePtr a -> m a
- freeStablePtr :: MonadIO m => StablePtr a -> m ()
- castStablePtrToPtr :: StablePtr a -> Ptr ()
- castPtrToStablePtr :: Ptr () -> StablePtr a
- class Storable a where
- alloca :: ( MonadUnliftIO m, Storable a) => ( Ptr a -> m b) -> m b
- allocaBytes :: MonadUnliftIO m => Int -> ( Ptr a -> m b) -> m b
- allocaBytesAligned :: MonadUnliftIO m => Int -> Int -> ( Ptr a -> m b) -> m b
- malloc :: ( MonadIO m, Storable a) => m ( Ptr a)
- mallocBytes :: MonadIO m => Int -> m ( Ptr a)
- calloc :: ( MonadIO m, Storable a) => m ( Ptr a)
- callocBytes :: MonadIO m => Int -> m ( Ptr a)
- realloc :: ( MonadIO m, Storable b) => Ptr a -> m ( Ptr b)
- reallocBytes :: MonadIO m => Ptr a -> Int -> m ( Ptr a)
- free :: MonadIO m => Ptr a -> m ()
- finalizerFree :: FinalizerPtr a
- mallocArray :: ( MonadIO m, Storable a) => Int -> m ( Ptr a)
- mallocArray0 :: ( MonadIO m, Storable a) => Int -> m ( Ptr a)
- allocaArray :: ( MonadUnliftIO m, Storable a) => Int -> ( Ptr a -> m b) -> m b
- allocaArray0 :: ( MonadUnliftIO m, Storable a) => Int -> ( Ptr a -> m b) -> m b
- reallocArray :: ( MonadIO m, Storable a) => Ptr a -> Int -> m ( Ptr a)
- reallocArray0 :: ( MonadIO m, Storable a) => Ptr a -> Int -> m ( Ptr a)
- callocArray :: ( MonadIO m, Storable a) => Int -> m ( Ptr a)
- callocArray0 :: ( MonadIO m, Storable a) => Int -> m ( Ptr a)
- peekArray :: ( MonadIO m, Storable a) => Int -> Ptr a -> m [a]
- peekArray0 :: ( MonadIO m, Storable a, Eq a) => a -> Ptr a -> m [a]
- pokeArray :: ( MonadIO m, Storable a) => Ptr a -> [a] -> m ()
- pokeArray0 :: ( MonadIO m, Storable a) => a -> Ptr a -> [a] -> m ()
- newArray :: ( MonadIO m, Storable a) => [a] -> m ( Ptr a)
- newArray0 :: ( MonadIO m, Storable a) => a -> [a] -> m ( Ptr a)
- withArray :: ( MonadUnliftIO m, Storable a) => [a] -> ( Ptr a -> m b) -> m b
- withArray0 :: ( MonadUnliftIO m, Storable a) => a -> [a] -> ( Ptr a -> m b) -> m b
- withArrayLen :: ( MonadUnliftIO m, Storable a) => [a] -> ( Int -> Ptr a -> m b) -> m b
- withArrayLen0 :: ( MonadUnliftIO m, Storable a) => a -> [a] -> ( Int -> Ptr a -> m b) -> m b
- copyArray :: ( MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m ()
- moveArray :: ( MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m ()
- lengthArray0 :: ( MonadIO m, Storable a, Eq a) => a -> Ptr a -> m Int
- advancePtr :: Storable a => Ptr a -> Int -> Ptr a
- throwIf :: MonadUnliftIO m => (a -> Bool ) -> (a -> String ) -> m a -> m a
- throwIf_ :: MonadUnliftIO m => (a -> Bool ) -> (a -> String ) -> m a -> m ()
- throwIfNeg :: ( MonadUnliftIO m, Ord a, Num a) => (a -> String ) -> m a -> m a
- throwIfNeg_ :: ( MonadUnliftIO m, Ord a, Num a) => (a -> String ) -> m a -> m ()
- throwIfNull :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a)
- data Pool
- newPool :: MonadIO m => m Pool
- freePool :: MonadIO m => Pool -> m ()
- withPool :: MonadUnliftIO m => ( Pool -> m b) -> m b
- pooledMalloc :: ( MonadIO m, Storable a) => Pool -> m ( Ptr a)
- pooledMallocBytes :: MonadIO m => Pool -> Int -> m ( Ptr a)
- pooledRealloc :: ( MonadIO m, Storable a) => Pool -> Ptr a -> m ( Ptr a)
- pooledReallocBytes :: MonadIO m => Pool -> Ptr a -> Int -> m ( Ptr a)
- pooledMallocArray :: ( MonadIO m, Storable a) => Pool -> Int -> m ( Ptr a)
- pooledMallocArray0 :: ( MonadIO m, Storable a) => Pool -> Int -> m ( Ptr a)
- pooledReallocArray :: ( MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m ( Ptr a)
- pooledReallocArray0 :: ( MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m ( Ptr a)
- pooledNew :: ( MonadIO m, Storable a) => Pool -> a -> m ( Ptr a)
- pooledNewArray :: ( MonadIO m, Storable a) => Pool -> [a] -> m ( Ptr a)
- pooledNewArray0 :: ( MonadIO m, Storable a) => Pool -> a -> [a] -> m ( Ptr a)
- with :: ( MonadUnliftIO m, Storable a) => a -> ( Ptr a -> m b) -> m b
- new :: ( MonadIO m, Storable a) => a -> m ( Ptr a)
- fromBool :: Num a => Bool -> a
- toBool :: ( Eq a, Num a) => a -> Bool
- maybeNew :: MonadIO m => (a -> m ( Ptr b)) -> Maybe a -> m ( Ptr b)
- maybeWith :: MonadIO m => (a -> ( Ptr b -> m c) -> m c) -> Maybe a -> ( Ptr b -> m c) -> m c
- maybePeek :: MonadUnliftIO m => ( Ptr a -> m b) -> Ptr a -> m ( Maybe b)
- withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
- copyBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m ()
- moveBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m ()
- fillBytes :: MonadIO m => Ptr a -> Word8 -> Int -> m ()
Re-exported modules
module Data.Bits
module Data.Int
module Data.Word
module Foreign.C.Types
Unlifted Foreign.C.String
type CString = Ptr CChar Source #
A C string is a reference to an array of C characters terminated by NUL.
type CStringLen = ( Ptr CChar , Int ) Source #
A string with explicit length information in bytes instead of a terminating NUL (allowing NUL characters in the middle of the string).
peekCString :: MonadIO m => CString -> m String Source #
Lifted
peekCString
.
Since: 0.2.5.0
peekCStringLen :: MonadIO m => CStringLen -> m String Source #
Lifted
peekCStringLen
.
Since: 0.2.5.0
newCString :: MonadIO m => String -> m CString Source #
Lifted
newCString
.
Since: 0.2.5.0
newCStringLen :: MonadIO m => String -> m CStringLen Source #
Lifted
newCStringLen
.
Since: 0.2.5.0
withCString :: MonadUnliftIO m => String -> ( CString -> m a) -> m a Source #
Unlifted
withCString
.
Since: 0.2.5.0
withCStringLen :: MonadUnliftIO m => String -> ( CStringLen -> m a) -> m a Source #
Unlifted
withCStringLen
.
Since: 0.2.5.0
castCharToCChar :: Char -> CChar Source #
Convert a Haskell character to a C character. This function is only safe on the first 256 characters.
castCCharToChar :: CChar -> Char Source #
Convert a C byte, representing a Latin-1 character, to the corresponding Haskell character.
castCharToCUChar :: Char -> CUChar Source #
Convert a Haskell character to a C
unsigned char
.
This function is only safe on the first 256 characters.
castCUCharToChar :: CUChar -> Char Source #
Convert a C
unsigned char
, representing a Latin-1 character, to
the corresponding Haskell character.
castCharToCSChar :: Char -> CSChar Source #
Convert a Haskell character to a C
signed char
.
This function is only safe on the first 256 characters.
castCSCharToChar :: CSChar -> Char Source #
Convert a C
signed char
, representing a Latin-1 character, to the
corresponding Haskell character.
peekCAString :: MonadIO m => CString -> m String Source #
Lifted
peekCAString
.
Since: 0.2.5.0
peekCAStringLen :: MonadIO m => CStringLen -> m String Source #
Lifted
peekCAStringLen
.
Since: 0.2.5.0
newCAString :: MonadIO m => String -> m CString Source #
Lifted
newCAString
.
Since: 0.2.5.0
newCAStringLen :: MonadIO m => String -> m CStringLen Source #
Lifted
newCAStringLen
.
Since: 0.2.5.0
withCAString :: MonadUnliftIO m => String -> ( CString -> m a) -> m a Source #
Unlifted
withCAString
.
Since: 0.2.5.0
withCAStringLen :: MonadUnliftIO m => String -> ( CStringLen -> m a) -> m a Source #
Unlifted
withCAStringLen
.
Since: 0.2.5.0
type CWString = Ptr CWchar Source #
A C wide string is a reference to an array of C wide characters terminated by NUL.
type CWStringLen = ( Ptr CWchar , Int ) Source #
A wide character string with explicit length information in
CWchar
s
instead of a terminating NUL (allowing NUL characters in the middle
of the string).
peekCWString :: MonadIO m => CWString -> m String Source #
Lifted
peekCWString
.
Since: 0.2.5.0
peekCWStringLen :: MonadIO m => CWStringLen -> m String Source #
Lifted
peekCWStringLen
.
Since: 0.2.5.0
newCWString :: MonadIO m => String -> m CWString Source #
Lifted
newCWString
.
Since: 0.2.5.0
newCWStringLen :: MonadIO m => String -> m CWStringLen Source #
Lifted
newCWStringLen
.
Since: 0.2.5.0
withCWString :: MonadUnliftIO m => String -> ( CWString -> m a) -> m a Source #
Unlifted
withCWString
.
Since: 0.2.5.0
withCWStringLen :: MonadUnliftIO m => String -> ( CWStringLen -> m a) -> m a Source #
Unlifted
withCWStringLen
.
Since: 0.2.5.0
Unlifted Foreign.C.Error
Haskell representation for
errno
values.
The implementation is deliberately exposed, to allow users to add
their own definitions of
Errno
values.
eADDRINUSE :: Errno Source #
eAFNOSUPPORT :: Errno Source #
eCONNABORTED :: Errno Source #
eCONNREFUSED :: Errno Source #
eCONNRESET :: Errno Source #
eDESTADDRREQ :: Errno Source #
eHOSTUNREACH :: Errno Source #
eINPROGRESS :: Errno Source #
eNAMETOOLONG :: Errno Source #
eNETUNREACH :: Errno Source #
eNOPROTOOPT :: Errno Source #
eOPNOTSUPP :: Errno Source #
ePFNOSUPPORT :: Errno Source #
ePROCUNAVAIL :: Errno Source #
ePROGUNAVAIL :: Errno Source #
ePROTOTYPE :: Errno Source #
eRPCMISMATCH :: Errno Source #
eTOOMANYREFS :: Errno Source #
eWOULDBLOCK :: Errno Source #
isValidErrno :: Errno -> Bool Source #
resetErrno :: MonadIO m => m () Source #
Lifted
resetErrno
.
Since: 0.2.5.0
throwErrno :: MonadIO m => String -> m a Source #
Lifted
throwErrno
.
Since: 0.2.5.0
throwErrnoIf :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m a Source #
Unlifted
throwErrnoIf
.
Since: 0.2.5.0
throwErrnoIf_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m () Source #
Unlifted
throwErrnoIf_
.
Since: 0.2.5.0
throwErrnoIfRetry :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m a Source #
Unlifted
throwErrnoIfRetry
.
Since: 0.2.5.0
throwErrnoIfRetry_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m () Source #
Unlifted
throwErrnoIfRetry_
.
Since: 0.2.5.0
throwErrnoIfMinus1 :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a Source #
Unlifted
throwErrnoIfMinus1
.
Since: 0.2.5.0
throwErrnoIfMinus1_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m () Source #
Unlifted
throwErrnoIfMinus1_
Since: 0.2.5.0
throwErrnoIfMinus1Retry :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a Source #
Unlifted
throwErrnoIfMinus1Retry
.
Since: 0.2.5.0
throwErrnoIfMinus1Retry_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m () Source #
Unlifted
throwErrnoIfMinus1Retry_
.
Since: 0.2.5.0
throwErrnoIfNull :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a) Source #
Unlifted
throwErrnoIfNull
.
Since: 0.2.5.0
throwErrnoIfNullRetry :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a) Source #
Unlifted
throwErrnoIfNullRetry
.
Since: 0.2.5.0
throwErrnoIfRetryMayBlock :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m b -> m a Source #
Unlifted
throwErrnoIfRetryMayBlock
.
Since: 0.2.5.0
throwErrnoIfRetryMayBlock_ :: MonadUnliftIO m => (a -> Bool ) -> String -> m a -> m b -> m () Source #
Unlifted
throwErrnoIfRetryMayBlock_
.
Since: 0.2.5.0
throwErrnoIfMinus1RetryMayBlock :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m a Source #
Unlifted
throwErrnoIfMinus1RetryMayBlock
.
Since: 0.2.5.0
throwErrnoIfMinus1RetryMayBlock_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m () Source #
Unlifted
throwErrnoIfMinus1RetryMayBlock_
Since: 0.2.5.0
throwErrnoIfNullRetryMayBlock :: MonadUnliftIO m => String -> m ( Ptr a) -> m b -> m ( Ptr a) Source #
Unlifted
throwErrnoIfNullRetryMayBlock
.
Since: 0.2.5.0
throwErrnoPath :: MonadIO m => String -> FilePath -> m a Source #
Lifted
throwErrnoPath
.
Since: 0.2.5.0
throwErrnoPathIf :: MonadUnliftIO m => (a -> Bool ) -> String -> FilePath -> m a -> m a Source #
Unlifted
throwErrnoPathIf
.
Since: 0.2.5.0
throwErrnoPathIf_ :: MonadUnliftIO m => (a -> Bool ) -> String -> FilePath -> m a -> m () Source #
Unlifted
throwErrnoPathIf_
.
Since: 0.2.5.0
throwErrnoPathIfNull :: MonadUnliftIO m => String -> FilePath -> m ( Ptr a) -> m ( Ptr a) Source #
Unlifted
throwErrnoPathIfNull
.
Since: 0.2.5.0
throwErrnoPathIfMinus1 :: ( MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m a Source #
Unlifted
throwErrnoPathIfMinus1
.
Since: 0.2.5.0
throwErrnoPathIfMinus1_ :: ( MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m () Source #
Unlifted
throwErrnoPathIfMinus1_
.
Since: 0.2.5.0
Unlifted Foreign.Ptr
A value of type
represents a pointer to an object, or an
array of objects, which may be marshalled to or from Haskell values
of type
Ptr
a
a
.
The type
a
will often be an instance of class
Storable
which provides the marshalling operations.
However this is not essential, and you can provide your own operations
to access the pointer. For example you might write small foreign
functions to get or set the fields of a C
struct
.
Instances
| NFData1 Ptr |
Since: deepseq-1.4.3.0 |
|
Defined in Control.DeepSeq |
|
| Generic1 ( URec ( Ptr ()) :: k -> Type ) |
Since: base-4.9.0.0 |
| Eq ( Ptr a) |
Since: base-2.1 |
| Ord ( Ptr a) |
Since: base-2.1 |
|
Defined in GHC.Ptr |
|
| Show ( Ptr a) |
Since: base-2.1 |
| Foldable ( UAddr :: Type -> Type ) |
Since: base-4.9.0.0 |
|
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # |
|
| Traversable ( UAddr :: Type -> Type ) |
Since: base-4.9.0.0 |
|
Defined in Data.Traversable |
|
| Storable ( Ptr a) |
Since: base-2.1 |
|
Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr ( Ptr a) -> Int -> IO ( Ptr a) Source # pokeElemOff :: Ptr ( Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source # |
|
| NFData ( Ptr a) |
Since: deepseq-1.4.2.0 |
|
Defined in Control.DeepSeq |
|
| Hashable ( Ptr a) | |
| Functor ( URec ( Ptr ()) :: Type -> Type ) |
Since: base-4.9.0.0 |
| Eq ( URec ( Ptr ()) p) |
Since: base-4.9.0.0 |
| Ord ( URec ( Ptr ()) p) |
Since: base-4.9.0.0 |
|
Defined in GHC.Generics Methods compare :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Ordering Source # (<) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (<=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # (>=) :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> Bool Source # max :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source # min :: URec ( Ptr ()) p -> URec ( Ptr ()) p -> URec ( Ptr ()) p Source # |
|
| Generic ( URec ( Ptr ()) p) |
Since: base-4.9.0.0 |
| data URec ( Ptr ()) (p :: k) |
Used for marking occurrences of
Since: base-4.9.0.0 |
| type Rep1 ( URec ( Ptr ()) :: k -> Type ) | |
|
Defined in GHC.Generics |
|
| type Rep ( URec ( Ptr ()) p) | |
|
Defined in GHC.Generics |
|
alignPtr :: Ptr a -> Int -> Ptr a Source #
Given an arbitrary address and an alignment constraint,
alignPtr
yields the next higher address that fulfills the
alignment constraint. An alignment constraint
x
is fulfilled by
any address divisible by
x
. This operation is idempotent.
minusPtr :: Ptr a -> Ptr b -> Int Source #
Computes the offset required to get from the second to the first argument. We have
p2 == p1 `plusPtr` (p2 `minusPtr` p1)
A value of type
is a pointer to a function callable
from foreign code. The type
FunPtr
a
a
will normally be a
foreign type
,
a function type with zero or more arguments where
-
the argument types are
marshallable foreign types
,
i.e.
Char,Int,Double,Float,Bool,Int8,Int16,Int32,Int64,Word8,Word16,Word32,Word64,PtraFunPtraStablePtranewtype. -
the return type is either a marshallable foreign type or has the form
IOttis a marshallable foreign type or().
A value of type
may be a pointer to a foreign function,
either returned by another foreign function or imported with a
a static address import like
FunPtr
a
foreign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a
wrapper
stub
declared to produce a
FunPtr
of the correct type. For example:
type Compare = Int -> Int -> Bool foreign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like
mkCompare
allocate storage, which
should be released with
freeHaskellFunPtr
when no
longer required.
To convert
FunPtr
values to corresponding Haskell functions, one
can define a
dynamic
stub for the specific foreign type, e.g.
type IntFunction = CInt -> IO () foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunction
Instances
| NFData1 FunPtr |
Since: deepseq-1.4.3.0 |
|
Defined in Control.DeepSeq |
|
| Eq ( FunPtr a) | |
| Ord ( FunPtr a) | |
|
Defined in GHC.Ptr |
|
| Show ( FunPtr a) |
Since: base-2.1 |
| Storable ( FunPtr a) |
Since: base-2.1 |
|
Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int Source # alignment :: FunPtr a -> Int Source # peekElemOff :: Ptr ( FunPtr a) -> Int -> IO ( FunPtr a) Source # pokeElemOff :: Ptr ( FunPtr a) -> Int -> FunPtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( FunPtr a) Source # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source # |
|
| NFData ( FunPtr a) |
Since: deepseq-1.4.2.0 |
|
Defined in Control.DeepSeq |
|
| Hashable ( FunPtr a) | |
nullFunPtr :: FunPtr a Source #
The constant
nullFunPtr
contains a
distinguished value of
FunPtr
that is not
associated with a valid memory location.
castFunPtrToPtr :: FunPtr a -> Ptr b Source #
castPtrToFunPtr :: Ptr a -> FunPtr b Source #
freeHaskellFunPtr :: MonadIO m => FunPtr a -> m () Source #
Lifted
freeHaskellFunPtr
.
Since: 0.2.5.0
A signed integral type that can be losslessly converted to and from
Ptr
. This type is also compatible with the C99 type
intptr_t
, and
can be marshalled to and from that type safely.
Instances
ptrToIntPtr :: Ptr a -> IntPtr Source #
casts a
Ptr
to an
IntPtr
intPtrToPtr :: IntPtr -> Ptr a Source #
casts an
IntPtr
to a
Ptr
An unsigned integral type that can be losslessly converted to and from
Ptr
. This type is also compatible with the C99 type
uintptr_t
, and
can be marshalled to and from that type safely.
Instances
ptrToWordPtr :: Ptr a -> WordPtr Source #
casts a
Ptr
to a
WordPtr
wordPtrToPtr :: WordPtr -> Ptr a Source #
casts a
WordPtr
to a
Ptr
Unlifted Foreign.ForeignPtr
data ForeignPtr a Source #
The type
ForeignPtr
represents references to objects that are
maintained in a foreign language, i.e., that are not part of the
data structures usually managed by the Haskell storage manager.
The essential difference between
ForeignPtr
s and vanilla memory
references of type
Ptr a
is that the former may be associated
with
finalizers
. A finalizer is a routine that is invoked when
the Haskell storage manager detects that - within the Haskell heap
and stack - there are no more references left that are pointing to
the
ForeignPtr
. Typically, the finalizer will, then, invoke
routines in the foreign language that free the resources bound by
the foreign object.
The
ForeignPtr
is parameterised in the same way as
Ptr
. The
type argument of
ForeignPtr
should normally be an instance of
class
Storable
.
Instances
| Eq ( ForeignPtr a) |
Since: base-2.1 |
|
Defined in GHC.ForeignPtr Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # |
|
| Ord ( ForeignPtr a) |
Since: base-2.1 |
|
Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering Source # (<) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source # |
|
| Show ( ForeignPtr a) |
Since: base-2.1 |
|
Defined in GHC.ForeignPtr |
|
type FinalizerPtr a = FunPtr ( Ptr a -> IO ()) Source #
A finalizer is represented as a pointer to a foreign function that, at finalisation time, gets as an argument a plain pointer variant of the foreign pointer that the finalizer is associated with.
Note that the foreign function
must
use the
ccall
calling convention.
newForeignPtr :: MonadIO m => FinalizerPtr a -> Ptr a -> m ( ForeignPtr a) Source #
Lifted
newForeignPtr
.
Since: 0.2.5.0
newForeignPtr_ :: MonadIO m => Ptr a -> m ( ForeignPtr a) Source #
Lifted
newForeignPtr_
.
Since: 0.2.5.0
addForeignPtrFinalizer :: MonadIO m => FinalizerPtr a -> ForeignPtr a -> m () Source #
Lifted
addForeignPtrFinalizer
.
Since: 0.2.5.0
newForeignPtrEnv :: MonadIO m => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> m ( ForeignPtr a) Source #
Lifted
newForeignPtrEnv
.
Since: 0.2.5.0
addForeignPtrFinalizerEnv :: MonadIO m => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> m () Source #
Lifted
addForeignPtrFinalizerEnv
.
Since: 0.2.5.0
withForeignPtr :: MonadUnliftIO m => ForeignPtr a -> ( Ptr a -> m b) -> m b Source #
Unlifted
withForeignPtr
.
Since: 0.2.5.0
finalizeForeignPtr :: MonadIO m => ForeignPtr a -> m () Source #
Lifted
finalizeForeignPtr
.
Since: 0.2.5.0
touchForeignPtr :: MonadIO m => ForeignPtr a -> m () Source #
Lifted
touchForeignPtr
.
Since: 0.2.5.0
castForeignPtr :: ForeignPtr a -> ForeignPtr b Source #
This function casts a
ForeignPtr
parameterised by one type into another type.
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b Source #
Advances the given address by the given offset in bytes.
The new
ForeignPtr
shares the finalizer of the original,
equivalent from a finalization standpoint to just creating another
reference to the original. That is, the finalizer will not be
called before the new
ForeignPtr
is unreachable, nor will it be
called an additional time due to this call, and the finalizer will
be called with the same address that it would have had this call
not happened, *not* the new address.
Since: base-4.10.0.0
mallocForeignPtr :: ( MonadIO m, Storable a) => m ( ForeignPtr a) Source #
Lifted
mallocForeignPtr
.
Since: 0.2.5.0
mallocForeignPtrBytes :: MonadIO m => Int -> m ( ForeignPtr a) Source #
Lifted
mallocForeignPtrBytes
.
Since: 0.2.5.0
mallocForeignPtrArray :: ( MonadIO m, Storable a) => Int -> m ( ForeignPtr a) Source #
Lifted
mallocForeignPtrArray
.
Since: 0.2.5.0
mallocForeignPtrArray0 :: ( MonadIO m, Storable a) => Int -> m ( ForeignPtr a) Source #
Lifted
mallocForeignPtrArray0
.
Since: 0.2.5.0
newGHCForeignPtr :: MonadUnliftIO m => Ptr a -> m () -> m ( ForeignPtr a) Source #
Unlifted
newForeignPtr
.
Since: 0.2.5.0
addGHCForeignPtrFinalizer :: MonadUnliftIO m => ForeignPtr a -> m () -> m () Source #
Unlifted
addForeignPtrFinalizer
.
Since: 0.2.5.0
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a Source #
This function extracts the pointer component of a foreign
pointer. This is a potentially dangerous operations, as if the
argument to
unsafeForeignPtrToPtr
is the last usage
occurrence of the given foreign pointer, then its finalizer(s) will
be run, which potentially invalidates the plain pointer just
obtained. Hence,
touchForeignPtr
must be used
wherever it has to be guaranteed that the pointer lives on - i.e.,
has another usage occurrence.
To avoid subtle coding errors, hand written marshalling code
should preferably use
withForeignPtr
rather
than combinations of
unsafeForeignPtrToPtr
and
touchForeignPtr
. However, the latter routines
are occasionally preferred in tool generated marshalling code.
Unlifted Foreign.StablePtr
A stable pointer is a reference to a Haskell expression that is guaranteed not to be affected by garbage collection, i.e., it will neither be deallocated nor will the value of the stable pointer itself change during garbage collection (ordinary references may be relocated during garbage collection). Consequently, stable pointers can be passed to foreign code, which can treat it as an opaque reference to a Haskell value.
A value of type
StablePtr a
is a stable pointer to a Haskell
expression of type
a
.
Instances
| Eq ( StablePtr a) |
Since: base-2.1 |
| Storable ( StablePtr a) |
Since: base-2.1 |
|
Defined in Foreign.Storable Methods sizeOf :: StablePtr a -> Int Source # alignment :: StablePtr a -> Int Source # peekElemOff :: Ptr ( StablePtr a) -> Int -> IO ( StablePtr a) Source # pokeElemOff :: Ptr ( StablePtr a) -> Int -> StablePtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO ( StablePtr a) Source # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () Source # |
|
newStablePtr :: MonadIO m => a -> m ( StablePtr a) Source #
Lifted
newStablePtr
.
Since: 0.2.5.0
deRefStablePtr :: MonadIO m => StablePtr a -> m a Source #
Lifted
deRefStablePtr
.
Since: 0.2.5.0
freeStablePtr :: MonadIO m => StablePtr a -> m () Source #
Lifted
freeStablePtr
.
Since: 0.2.5.0
castStablePtrToPtr :: StablePtr a -> Ptr () Source #
Coerce a stable pointer to an address. No guarantees are made about
the resulting value, except that the original stable pointer can be
recovered by
castPtrToStablePtr
. In particular, the address may not
refer to an accessible memory location and any attempt to pass it to
the member functions of the class
Storable
leads to
undefined behaviour.
castPtrToStablePtr :: Ptr () -> StablePtr a Source #
The inverse of
castStablePtrToPtr
, i.e., we have the identity
sp == castPtrToStablePtr (castStablePtrToPtr sp)
for any stable pointer
sp
on which
freeStablePtr
has
not been executed yet. Moreover,
castPtrToStablePtr
may
only be applied to pointers that have been produced by
castStablePtrToPtr
.
Unlifted Foreign.Storable
class Storable a where Source #
The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.
Memory addresses are represented as values of type
, for some
Ptr
a
a
which is an instance of class
Storable
. The type argument to
Ptr
helps provide some valuable type safety in FFI code (you can't
mix pointers of different types without an explicit cast), while
helping the Haskell type system figure out which marshalling method is
needed for a given pointer.
All marshalling between Haskell and a foreign language ultimately
boils down to translating Haskell data structures into the binary
representation of a corresponding data structure of the foreign
language and vice versa. To code this marshalling in Haskell, it is
necessary to manipulate primitive data types stored in unstructured
memory blocks. The class
Storable
facilitates this manipulation on
all types for which it is instantiated, which are the standard basic
types of Haskell, the fixed size
Int
types (
Int8
,
Int16
,
Int32
,
Int64
), the fixed size
Word
types (
Word8
,
Word16
,
Word32
,
Word64
),
StablePtr
, all types from
Foreign.C.Types
,
as well as
Ptr
.
Minimal complete definition
sizeOf , alignment , ( peek | peekElemOff | peekByteOff ), ( poke | pokeElemOff | pokeByteOff )
Methods
Computes the storage requirements (in bytes) of the argument. The value of the argument is not used.
alignment :: a -> Int Source #
Computes the alignment constraint of the argument. An
alignment constraint
x
is fulfilled by any address divisible
by
x
. The value of the argument is not used.
peekElemOff :: Ptr a -> Int -> IO a Source #
Read a value from a memory area regarded as an array
of values of the same kind. The first argument specifies
the start address of the array and the second the index into
the array (the first element of the array has index
0
). The following equality holds,
peekElemOff addr idx = IOExts.fixIO $ \result -> peek (addr `plusPtr` (idx * sizeOf result))
Note that this is only a specification, not necessarily the concrete implementation of the function.
pokeElemOff :: Ptr a -> Int -> a -> IO () Source #
Write a value to a memory area regarded as an array of values of the same kind. The following equality holds:
pokeElemOff addr idx x = poke (addr `plusPtr` (idx * sizeOf x)) x
peekByteOff :: Ptr b -> Int -> IO a Source #
Read a value from a memory location given by a base address and offset. The following equality holds:
peekByteOff addr off = peek (addr `plusPtr` off)
pokeByteOff :: Ptr b -> Int -> a -> IO () Source #
Write a value to a memory location given by a base address and offset. The following equality holds:
pokeByteOff addr off x = poke (addr `plusPtr` off) x
peek :: Ptr a -> IO a Source #
Read a value from the given memory location.
Note that the peek and poke functions might require properly
aligned addresses to function correctly. This is architecture
dependent; thus, portable code should ensure that when peeking or
poking values of some type
a
, the alignment
constraint for
a
, as given by the function
alignment
is fulfilled.
poke :: Ptr a -> a -> IO () Source #
Write the given value to the given memory location. Alignment
restrictions might apply; see
peek
.
Instances
Unlifted Foreign.Marshal.Alloc
alloca :: ( MonadUnliftIO m, Storable a) => ( Ptr a -> m b) -> m b Source #
Unlifted
alloca
.
Since: 0.2.5.0
allocaBytes :: MonadUnliftIO m => Int -> ( Ptr a -> m b) -> m b Source #
Unlifted
allocaBytes
.
Since: 0.2.5.0
allocaBytesAligned :: MonadUnliftIO m => Int -> Int -> ( Ptr a -> m b) -> m b Source #
Unlifted
allocaBytesAligned
.
Since: 0.2.5.0
mallocBytes :: MonadIO m => Int -> m ( Ptr a) Source #
Lifted
mallocBytes
.
Since: 0.2.5.0
callocBytes :: MonadIO m => Int -> m ( Ptr a) Source #
Lifted
callocBytes
.
Since: 0.2.5.0
reallocBytes :: MonadIO m => Ptr a -> Int -> m ( Ptr a) Source #
Lifted
reallocBytes
.
Since: 0.2.5.0
finalizerFree :: FinalizerPtr a Source #
A pointer to a foreign function equivalent to
free
, which may be
used as a finalizer (cf
ForeignPtr
) for storage
allocated with
malloc
,
mallocBytes
,
realloc
or
reallocBytes
.
Unlifted Foreign.Marshal.Array
mallocArray :: ( MonadIO m, Storable a) => Int -> m ( Ptr a) Source #
Lifted
mallocArray
.
Since: 0.2.5.0
mallocArray0 :: ( MonadIO m, Storable a) => Int -> m ( Ptr a) Source #
Lifted
mallocArray0
.
Since: 0.2.5.0
allocaArray :: ( MonadUnliftIO m, Storable a) => Int -> ( Ptr a -> m b) -> m b Source #
Unlifted
allocaArray
.
Since: 0.2.5.0
allocaArray0 :: ( MonadUnliftIO m, Storable a) => Int -> ( Ptr a -> m b) -> m b Source #
Unlifted
allocaArray0
.
Since: 0.2.5.0
reallocArray :: ( MonadIO m, Storable a) => Ptr a -> Int -> m ( Ptr a) Source #
Lifted
reallocArray
.
Since: 0.2.5.0
reallocArray0 :: ( MonadIO m, Storable a) => Ptr a -> Int -> m ( Ptr a) Source #
Lifted
reallocArray0
.
Since: 0.2.5.0
callocArray :: ( MonadIO m, Storable a) => Int -> m ( Ptr a) Source #
Lifted
callocArray
.
Since: 0.2.5.0
callocArray0 :: ( MonadIO m, Storable a) => Int -> m ( Ptr a) Source #
Lifted
callocArray0
.
Since: 0.2.5.0
peekArray :: ( MonadIO m, Storable a) => Int -> Ptr a -> m [a] Source #
Lifted
peekArray
.
Since: 0.2.5.0
peekArray0 :: ( MonadIO m, Storable a, Eq a) => a -> Ptr a -> m [a] Source #
Lifted
peekArray0
.
Since: 0.2.5.0
pokeArray :: ( MonadIO m, Storable a) => Ptr a -> [a] -> m () Source #
Lifted
pokeArray
.
Since: 0.2.5.0
pokeArray0 :: ( MonadIO m, Storable a) => a -> Ptr a -> [a] -> m () Source #
Lifted
pokeArray0
.
Since: 0.2.5.0
newArray0 :: ( MonadIO m, Storable a) => a -> [a] -> m ( Ptr a) Source #
Lifted
newArray0
Since: 0.2.5.0
withArray :: ( MonadUnliftIO m, Storable a) => [a] -> ( Ptr a -> m b) -> m b Source #
Unlifted
withArray
.
Since: 0.2.5.0
withArray0 :: ( MonadUnliftIO m, Storable a) => a -> [a] -> ( Ptr a -> m b) -> m b Source #
Unlifted
withArray0
.
Since: 0.2.5.0
withArrayLen :: ( MonadUnliftIO m, Storable a) => [a] -> ( Int -> Ptr a -> m b) -> m b Source #
Unlifted
withArrayLen
.
Since: 0.2.5.0
withArrayLen0 :: ( MonadUnliftIO m, Storable a) => a -> [a] -> ( Int -> Ptr a -> m b) -> m b Source #
Unlifted
withArrayLen0
.
Since: 0.2.5.0
copyArray :: ( MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m () Source #
Lifted
copyArray
.
Since: 0.2.5.0
moveArray :: ( MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m () Source #
Lifted
moveArray
.
Since: 0.2.5.0
lengthArray0 :: ( MonadIO m, Storable a, Eq a) => a -> Ptr a -> m Int Source #
Lifted
lengthArray0
.
Since: 0.2.5.0
advancePtr :: Storable a => Ptr a -> Int -> Ptr a Source #
Advance a pointer into an array by the given number of elements
Unlifted Foreign.Marshal.Error
throwIf :: MonadUnliftIO m => (a -> Bool ) -> (a -> String ) -> m a -> m a Source #
Unlifted
throwIf
.
Since: 0.2.5.0
throwIf_ :: MonadUnliftIO m => (a -> Bool ) -> (a -> String ) -> m a -> m () Source #
Unlifted
throwIf_
.
Since: 0.2.5.0
throwIfNeg :: ( MonadUnliftIO m, Ord a, Num a) => (a -> String ) -> m a -> m a Source #
Unlifted
throwIfNeg
.
Since: 0.2.5.0
throwIfNeg_ :: ( MonadUnliftIO m, Ord a, Num a) => (a -> String ) -> m a -> m () Source #
Unlifted
throwIfNeg_
.
Since: 0.2.5.0
throwIfNull :: MonadUnliftIO m => String -> m ( Ptr a) -> m ( Ptr a) Source #
Unlifted
throwIfNull
.
Since: 0.2.5.0
Unlifted Foreign.Marshal.Pool
pooledMalloc :: ( MonadIO m, Storable a) => Pool -> m ( Ptr a) Source #
Lifted
pooledMalloc
.
Since: 0.2.5.0
pooledMallocBytes :: MonadIO m => Pool -> Int -> m ( Ptr a) Source #
Lifted
pooledMallocBytes
.
Since: 0.2.5.0
pooledRealloc :: ( MonadIO m, Storable a) => Pool -> Ptr a -> m ( Ptr a) Source #
Lifted
pooledRealloc
.
Since: 0.2.5.0
pooledReallocBytes :: MonadIO m => Pool -> Ptr a -> Int -> m ( Ptr a) Source #
Lifted
pooledReallocBytes
.
Since: 0.2.5.0
pooledMallocArray :: ( MonadIO m, Storable a) => Pool -> Int -> m ( Ptr a) Source #
Lifted
pooledMallocArray
.
Since: 0.2.5.0
pooledMallocArray0 :: ( MonadIO m, Storable a) => Pool -> Int -> m ( Ptr a) Source #
Lifted
pooledMallocArray0
.
Since: 0.2.5.0
pooledReallocArray :: ( MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m ( Ptr a) Source #
Lifted
pooledReallocArray
.
Since: 0.2.5.0
pooledReallocArray0 :: ( MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m ( Ptr a) Source #
Lifted
pooledReallocArray0
.
Since: 0.2.5.0
pooledNew :: ( MonadIO m, Storable a) => Pool -> a -> m ( Ptr a) Source #
Lifted
pooledNew
.
Since: 0.2.5.0
pooledNewArray :: ( MonadIO m, Storable a) => Pool -> [a] -> m ( Ptr a) Source #
Lifted
pooledNewArray
.
Since: 0.2.5.0
pooledNewArray0 :: ( MonadIO m, Storable a) => Pool -> a -> [a] -> m ( Ptr a) Source #
Lifted
pooledNewArray0
.
Since: 0.2.5.0
Unlifted Foreign.Marshal.Utils
with :: ( MonadUnliftIO m, Storable a) => a -> ( Ptr a -> m b) -> m b Source #
Unlifted
with
.
Since: 0.2.5.0
toBool :: ( Eq a, Num a) => a -> Bool Source #
Convert a Boolean in numeric representation to a Haskell value
maybeNew :: MonadIO m => (a -> m ( Ptr b)) -> Maybe a -> m ( Ptr b) Source #
Lifted
maybeNew
.
Since: 0.2.5.0
maybeWith :: MonadIO m => (a -> ( Ptr b -> m c) -> m c) -> Maybe a -> ( Ptr b -> m c) -> m c Source #
Lifted
maybeWith
.
Since: 0.2.5.0
maybePeek :: MonadUnliftIO m => ( Ptr a -> m b) -> Ptr a -> m ( Maybe b) Source #
Unlifted
maybePeek
.
Since: 0.2.5.0