| Safe Haskell | Safe-Inferred |
|---|---|
| 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 CStringLen = (Ptr CChar, Int) #
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
charIsRepresentable :: Char -> IO Bool #
castCharToCChar :: Char -> CChar #
Convert a Haskell character to a C character. This function is only safe on the first 256 characters.
castCCharToChar :: CChar -> Char #
Convert a C byte, representing a Latin-1 character, to the corresponding Haskell character.
castCharToCUChar :: Char -> CUChar #
Convert a Haskell character to a C unsigned char.
This function is only safe on the first 256 characters.
castCUCharToChar :: CUChar -> Char #
Convert a C unsigned char, representing a Latin-1 character, to
the corresponding Haskell character.
castCharToCSChar :: Char -> CSChar #
Convert a Haskell character to a C signed char.
This function is only safe on the first 256 characters.
castCSCharToChar :: CSChar -> Char #
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
A C wide string is a reference to an array of C wide characters terminated by NUL.
type CWStringLen = (Ptr CWchar, Int) #
A wide character string with explicit length information in CWchars
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 #
eADDRNOTAVAIL :: Errno #
eAFNOSUPPORT :: Errno #
eCONNABORTED :: Errno #
eCONNREFUSED :: Errno #
eCONNRESET :: Errno #
eDESTADDRREQ :: Errno #
eHOSTUNREACH :: Errno #
eINPROGRESS :: Errno #
eNAMETOOLONG :: Errno #
eNETUNREACH :: Errno #
eNOPROTOOPT :: Errno #
eOPNOTSUPP :: Errno #
ePFNOSUPPORT :: Errno #
ePROCUNAVAIL :: Errno #
ePROGMISMATCH :: Errno #
ePROGUNAVAIL :: Errno #
ePROTOTYPE :: Errno #
eRPCMISMATCH :: Errno #
eTOOMANYREFS :: Errno #
eWOULDBLOCK :: Errno #
isValidErrno :: Errno -> Bool #
resetErrno :: MonadIO m => m () Source #
Lifted resetErrno.
Since: 0.2.5.0
Arguments
| :: String | the location where the error occurred |
| -> Errno | the error number |
| -> Maybe Handle | optional handle associated with the error |
| -> Maybe String | optional filename associated with the error |
| -> IOError |
Construct an IOException based on the given Errno value.
The optional information can be used to improve the accuracy of
error messages.
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 Ptr aa.
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) | |
| Foldable (UAddr :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
| Traversable (UAddr :: Type -> Type) | Since: base-4.9.0.0 |
| Storable (Ptr a) | Since: base-2.1 |
| Show (Ptr a) | Since: base-2.1 |
| NFData (Ptr a) | Since: deepseq-1.4.2.0 |
Defined in Control.DeepSeq | |
| Eq (Ptr a) | Since: base-2.1 |
| Ord (Ptr a) | Since: base-2.1 |
| Hashable (Ptr a) | |
| Functor (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |
| Generic (URec (Ptr ()) p) | |
| 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 # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
| data URec (Ptr ()) (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| type Rep1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Rep (URec (Ptr ()) p) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
alignPtr :: Ptr a -> Int -> Ptr a #
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 #
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 FunPtr aa 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 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 | |
| Storable (FunPtr a) | Since: base-2.1 |
Defined in Foreign.Storable | |
| Show (FunPtr a) | Since: base-2.1 |
| NFData (FunPtr a) | Since: deepseq-1.4.2.0 |
Defined in Control.DeepSeq | |
| Eq (FunPtr a) | |
| Ord (FunPtr a) | |
Defined in GHC.Ptr | |
| Hashable (FunPtr a) | |
nullFunPtr :: FunPtr a #
The constant nullFunPtr contains a
distinguished value of FunPtr that is not
associated with a valid memory location.
castFunPtrToPtr :: FunPtr a -> Ptr b #
castPtrToFunPtr :: Ptr a -> FunPtr b #
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 #
casts a Ptr to an IntPtr
intPtrToPtr :: IntPtr -> Ptr a #
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 #
casts a Ptr to a WordPtr
wordPtrToPtr :: WordPtr -> Ptr a #
casts a WordPtr to a Ptr
Unlifted Foreign.ForeignPtr
data ForeignPtr a #
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 ForeignPtrs 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
| Show (ForeignPtr a) | Since: base-2.1 |
Defined in GHC.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS # | |
| Eq (ForeignPtr a) | Since: base-2.1 |
Defined in GHC.ForeignPtr | |
| Ord (ForeignPtr a) | Since: base-2.1 |
Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool # (>) :: ForeignPtr a -> ForeignPtr a -> Bool # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # | |
type FinalizerPtr a = FunPtr (Ptr a -> IO ()) #
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 #
This function casts a ForeignPtr
parameterised by one type into another type.
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b #
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 #
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.
The StablePtr 0 is reserved for representing NULL in foreign code.
A value of type StablePtr a is a stable pointer to a Haskell
expression of type a.
Instances
| Storable (StablePtr a) | Since: base-2.1 |
Defined in Foreign.Storable Methods sizeOf :: StablePtr a -> Int # alignment :: StablePtr a -> Int # peekElemOff :: Ptr (StablePtr a) -> Int -> IO (StablePtr a) # pokeElemOff :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (StablePtr a) # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () # | |
| Eq (StablePtr a) | Since: base-2.1 |
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 () #
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 might 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 #
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
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 Ptr aa 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.
Computes the alignment constraint of the argument. An
alignment constraint x is fulfilled by any address divisible
by x. The alignment must be a power of two if this instance
is to be used with alloca or allocaArray. The value of
the argument is not used.
peekElemOff :: Ptr a -> Int -> IO a #
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 () #
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 #
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 () #
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
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.
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 #
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 #
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 #
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