unliftio-0.2.25.1: The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)

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
  - sizeOf :: a -> Int
  - alignment :: a -> Int
  - peekElemOff :: Ptr a -> Int -> IO a
  - pokeElemOff :: Ptr a -> Int -> a -> IO ()
  - peekByteOff :: Ptr b -> Int -> IO a
  - pokeByteOff :: Ptr b -> Int -> a -> IO ()
  - peek :: Ptr a -> IO a
  - poke :: Ptr a -> a -> IO ()
- 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

charIsRepresentable :: Char -> IO Bool Source #

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

newtype Errno Source #

Haskell representation for `errno` values. The implementation is deliberately exposed, to allow users to add their own definitions of `Errno` values.

Constructors

Errno CInt |

#### Instances

Instances details

Eq Errno | Since: base-2.1
Instance details Defined in GHC.Internal.Foreign.C.Error Methods (==) :: Errno -> Errno -> Bool Source # (/=) :: Errno -> Errno -> Bool Source #

eOK :: Errno Source #

e2BIG :: Errno Source #

eACCES :: Errno Source #

eADDRINUSE :: Errno Source #

eADDRNOTAVAIL :: Errno Source #

eADV :: Errno Source #

eAFNOSUPPORT :: Errno Source #

eAGAIN :: Errno Source #

eALREADY :: Errno Source #

eBADF :: Errno Source #

eBADMSG :: Errno Source #

eBADRPC :: Errno Source #

eBUSY :: Errno Source #

eCHILD :: Errno Source #

eCOMM :: Errno Source #

eCONNABORTED :: Errno Source #

eCONNREFUSED :: Errno Source #

eCONNRESET :: Errno Source #

eDEADLK :: Errno Source #

eDESTADDRREQ :: Errno Source #

eDIRTY :: Errno Source #

eDOM :: Errno Source #

eDQUOT :: Errno Source #

eEXIST :: Errno Source #

eFAULT :: Errno Source #

eFBIG :: Errno Source #

eFTYPE :: Errno Source #

eHOSTDOWN :: Errno Source #

eHOSTUNREACH :: Errno Source #

eIDRM :: Errno Source #

eILSEQ :: Errno Source #

eINPROGRESS :: Errno Source #

eINTR :: Errno Source #

eINVAL :: Errno Source #

eIO :: Errno Source #

eISCONN :: Errno Source #

eISDIR :: Errno Source #

eLOOP :: Errno Source #

eMFILE :: Errno Source #

eMLINK :: Errno Source #

eMSGSIZE :: Errno Source #

eMULTIHOP :: Errno Source #

eNAMETOOLONG :: Errno Source #

eNETDOWN :: Errno Source #

eNETRESET :: Errno Source #

eNETUNREACH :: Errno Source #

eNFILE :: Errno Source #

eNOBUFS :: Errno Source #

eNODATA :: Errno Source #

eNODEV :: Errno Source #

eNOENT :: Errno Source #

eNOEXEC :: Errno Source #

eNOLCK :: Errno Source #

eNOLINK :: Errno Source #

eNOMEM :: Errno Source #

eNOMSG :: Errno Source #

eNONET :: Errno Source #

eNOPROTOOPT :: Errno Source #

eNOSPC :: Errno Source #

eNOSR :: Errno Source #

eNOSTR :: Errno Source #

eNOSYS :: Errno Source #

eNOTBLK :: Errno Source #

eNOTCONN :: Errno Source #

eNOTDIR :: Errno Source #

eNOTEMPTY :: Errno Source #

eNOTSOCK :: Errno Source #

eNOTSUP :: Errno Source #

Since: base-4.7.0.0

eNOTTY :: Errno Source #

eNXIO :: Errno Source #

eOPNOTSUPP :: Errno Source #

ePERM :: Errno Source #

ePFNOSUPPORT :: Errno Source #

ePIPE :: Errno Source #

ePROCLIM :: Errno Source #

ePROCUNAVAIL :: Errno Source #

ePROGMISMATCH :: Errno Source #

ePROGUNAVAIL :: Errno Source #

ePROTO :: Errno Source #

ePROTONOSUPPORT :: Errno Source #

ePROTOTYPE :: Errno Source #

eRANGE :: Errno Source #

eREMCHG :: Errno Source #

eREMOTE :: Errno Source #

eROFS :: Errno Source #

eRPCMISMATCH :: Errno Source #

eRREMOTE :: Errno Source #

eSHUTDOWN :: Errno Source #

eSOCKTNOSUPPORT :: Errno Source #

eSPIPE :: Errno Source #

eSRCH :: Errno Source #

eSRMNT :: Errno Source #

eSTALE :: Errno Source #

eTIME :: Errno Source #

eTIMEDOUT :: Errno Source #

eTOOMANYREFS :: Errno Source #

eTXTBSY :: Errno Source #

eUSERS :: Errno Source #

eWOULDBLOCK :: Errno Source #

eXDEV :: Errno Source #

isValidErrno :: Errno -> Bool Source #

Yield `True` if the given `Errno` value is valid on the system. This implies that the `Eq` instance of `Errno` is also system dependent as it is only defined for valid values of `Errno`.

getErrno :: MonadIO m => m Errno Source #

Lifted `getErrno`.

Since: 0.2.5.0

resetErrno :: MonadIO m => m () Source #

Lifted `resetErrno`.

Since: 0.2.5.0

errnoToIOError Source #

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 `IOError` 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

data Ptr a Source #

A value of type ``Ptr` a` represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type `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

Instances details

NFData1 Ptr | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Ptr a -> () Source #
Generic1 (URec (Ptr ()) :: k -> Type) |

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))

Methods

from1 :: forall (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ()) :: k -> Type) a Source #

to1 :: forall (a :: k). Rep1 (URec (Ptr ()) :: k -> Type) a -> URec (Ptr ()) a Source #

NFData (Ptr a) | Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Ptr a -> () Source #
Foldable (UAddr :: Type -> Type) | Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.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 #

sum :: Num a => UAddr a -> a Source #

product :: Num a => UAddr a -> a Source #

Traversable (UAddr :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m (UAddr a) Source #
Storable (Ptr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (Ptr a) -> IO (Ptr a) Source #

poke :: Ptr (Ptr a) -> Ptr a -> IO () Source #

Show (Ptr a) | Since: base-2.1
Instance details Defined in GHC.Internal.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS Source # show :: Ptr a -> String Source # showList :: [Ptr a] -> ShowS Source #
Eq (Ptr a) | Since: base-2.1
Instance details Defined in GHC.Internal.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool Source # (/=) :: Ptr a -> Ptr a -> Bool Source #
Ord (Ptr a) | Since: base-2.1
Instance details Defined in GHC.Internal.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering Source # (<) :: Ptr a -> Ptr a -> Bool Source # (<=) :: Ptr a -> Ptr a -> Bool Source # (>) :: Ptr a -> Ptr a -> Bool Source # (>=) :: Ptr a -> Ptr a -> Bool Source # max :: Ptr a -> Ptr a -> Ptr a Source # min :: Ptr a -> Ptr a -> Ptr a Source #
Hashable (Ptr a) |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int hash :: Ptr a -> Int
Functor (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source #
Generic (URec (Ptr ()) p) |

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec (Ptr ()) p) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source #

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #

Eq (URec (Ptr ()) p) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source #
Ord (URec (Ptr ()) p) | Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.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 #

data URec (Ptr ()) (p :: k) | Used for marking occurrences of `Addr#` Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

data URec (Ptr ()) (p :: k) = UAddr {

- uAddr# :: Addr#

}

type Rep1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))
type Rep (URec (Ptr ()) p) | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

nullPtr :: Ptr a Source #

The constant `nullPtr` contains a distinguished value of `Ptr` that is not associated with a valid memory location.

castPtr :: Ptr a -> Ptr b Source #

The `castPtr` function casts a pointer from one type to another.

plusPtr :: Ptr a -> Int -> Ptr b Source #

Advances the given address by the given offset in bytes.

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)

data FunPtr a Source #

A value of type ``FunPtr` a` is a pointer to a function callable from foreign code. The type `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`, ``Ptr` a`, ``FunPtr` a`, ``StablePtr` a` or a renaming of any of these using `newtype`.
- the return type is either a marshallable foreign type or has the form ``IO` t` where `t` is a marshallable foreign type or `()`.

A value of type ``FunPtr` a` may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

    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

Instances details

NFData1 FunPtr | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> FunPtr a -> () Source #
NFData (FunPtr a) | Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: FunPtr a -> () Source #
Storable (FunPtr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (FunPtr a) -> IO (FunPtr a) Source #

poke :: Ptr (FunPtr a) -> FunPtr a -> IO () Source #

Show (FunPtr a) | Since: base-2.1
Instance details Defined in GHC.Internal.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS Source # show :: FunPtr a -> String Source # showList :: [FunPtr a] -> ShowS Source #
Eq (FunPtr a) |
Instance details Defined in GHC.Internal.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool Source # (/=) :: FunPtr a -> FunPtr a -> Bool Source #
Ord (FunPtr a) |
Instance details Defined in GHC.Internal.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering Source # (<) :: FunPtr a -> FunPtr a -> Bool Source # (<=) :: FunPtr a -> FunPtr a -> Bool Source # (>) :: FunPtr a -> FunPtr a -> Bool Source # (>=) :: FunPtr a -> FunPtr a -> Bool Source # max :: FunPtr a -> FunPtr a -> FunPtr a Source # min :: FunPtr a -> FunPtr a -> FunPtr a Source #
Hashable (FunPtr a) |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int hash :: FunPtr a -> Int

nullFunPtr :: FunPtr a Source #

The constant `nullFunPtr` contains a distinguished value of `FunPtr` that is not associated with a valid memory location.

castFunPtr :: FunPtr a -> FunPtr b Source #

Casts a `FunPtr` to a `FunPtr` of a different type.

castFunPtrToPtr :: FunPtr a -> Ptr b Source #

Casts a `FunPtr` to a `Ptr`.

Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.

castPtrToFunPtr :: Ptr a -> FunPtr b Source #

Casts a `Ptr` to a `FunPtr`.

Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.

freeHaskellFunPtr :: MonadIO m => FunPtr a -> m () Source #

Lifted `freeHaskellFunPtr`.

Since: 0.2.5.0

newtype IntPtr Source #

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.

Constructors

IntPtr Int |

#### Instances

Instances details

Bits IntPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: IntPtr -> IntPtr -> IntPtr Source #

(.|.) :: IntPtr -> IntPtr -> IntPtr Source #

xor :: IntPtr -> IntPtr -> IntPtr Source #

complement :: IntPtr -> IntPtr Source #

shift :: IntPtr -> Int -> IntPtr Source #

rotate :: IntPtr -> Int -> IntPtr Source #

zeroBits :: IntPtr Source #

bit :: Int -> IntPtr Source #

setBit :: IntPtr -> Int -> IntPtr Source #

clearBit :: IntPtr -> Int -> IntPtr Source #

complementBit :: IntPtr -> Int -> IntPtr Source #

testBit :: IntPtr -> Int -> Bool Source #

bitSizeMaybe :: IntPtr -> Maybe Int Source #

bitSize :: IntPtr -> Int Source #

isSigned :: IntPtr -> Bool Source #

shiftL :: IntPtr -> Int -> IntPtr Source #

unsafeShiftL :: IntPtr -> Int -> IntPtr Source #

shiftR :: IntPtr -> Int -> IntPtr Source #

unsafeShiftR :: IntPtr -> Int -> IntPtr Source #

rotateL :: IntPtr -> Int -> IntPtr Source #

rotateR :: IntPtr -> Int -> IntPtr Source #

popCount :: IntPtr -> Int Source #

FiniteBits IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods finiteBitSize :: IntPtr -> Int Source # countLeadingZeros :: IntPtr -> Int Source # countTrailingZeros :: IntPtr -> Int Source #
Bounded IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods minBound :: IntPtr Source # maxBound :: IntPtr Source #
Enum IntPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

succ :: IntPtr -> IntPtr Source #

pred :: IntPtr -> IntPtr Source #

toEnum :: Int -> IntPtr Source #

fromEnum :: IntPtr -> Int Source #

enumFrom :: IntPtr -> [IntPtr] Source #

enumFromThen :: IntPtr -> IntPtr -> [IntPtr] Source #

enumFromTo :: IntPtr -> IntPtr -> [IntPtr] Source #

enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr] Source #

Storable IntPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: IntPtr -> Int Source #

alignment :: IntPtr -> Int Source #

peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr Source #

pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO IntPtr Source #

pokeByteOff :: Ptr b -> Int -> IntPtr -> IO () Source #

peek :: Ptr IntPtr -> IO IntPtr Source #

poke :: Ptr IntPtr -> IntPtr -> IO () Source #

Ix IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods range :: (IntPtr, IntPtr) -> [IntPtr] Source # index :: (IntPtr, IntPtr) -> IntPtr -> Int Source # unsafeIndex :: (IntPtr, IntPtr) -> IntPtr -> Int Source # inRange :: (IntPtr, IntPtr) -> IntPtr -> Bool Source # rangeSize :: (IntPtr, IntPtr) -> Int Source # unsafeRangeSize :: (IntPtr, IntPtr) -> Int Source #
Num IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (+) :: IntPtr -> IntPtr -> IntPtr Source # (-) :: IntPtr -> IntPtr -> IntPtr Source # (*) :: IntPtr -> IntPtr -> IntPtr Source # negate :: IntPtr -> IntPtr Source # abs :: IntPtr -> IntPtr Source # signum :: IntPtr -> IntPtr Source # fromInteger :: Integer -> IntPtr Source #
Read IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods readsPrec :: Int -> ReadS IntPtr Source # readList :: ReadS [IntPtr] Source # readPrec :: ReadPrec IntPtr Source # readListPrec :: ReadPrec [IntPtr] Source #
Integral IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods quot :: IntPtr -> IntPtr -> IntPtr Source # rem :: IntPtr -> IntPtr -> IntPtr Source # div :: IntPtr -> IntPtr -> IntPtr Source # mod :: IntPtr -> IntPtr -> IntPtr Source # quotRem :: IntPtr -> IntPtr -> (IntPtr, IntPtr) Source # divMod :: IntPtr -> IntPtr -> (IntPtr, IntPtr) Source # toInteger :: IntPtr -> Integer Source #
Real IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods toRational :: IntPtr -> Rational Source #
Show IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods showsPrec :: Int -> IntPtr -> ShowS Source # show :: IntPtr -> String Source # showList :: [IntPtr] -> ShowS Source #
Eq IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (==) :: IntPtr -> IntPtr -> Bool Source # (/=) :: IntPtr -> IntPtr -> Bool Source #
Ord IntPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods compare :: IntPtr -> IntPtr -> Ordering Source # (<) :: IntPtr -> IntPtr -> Bool Source # (<=) :: IntPtr -> IntPtr -> Bool Source # (>) :: IntPtr -> IntPtr -> Bool Source # (>=) :: IntPtr -> IntPtr -> Bool Source # max :: IntPtr -> IntPtr -> IntPtr Source # min :: IntPtr -> IntPtr -> IntPtr Source #
Hashable IntPtr |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntPtr -> Int hash :: IntPtr -> Int

ptrToIntPtr :: Ptr a -> IntPtr Source #

casts a `Ptr` to an `IntPtr`

intPtrToPtr :: IntPtr -> Ptr a Source #

casts an `IntPtr` to a `Ptr`

newtype WordPtr Source #

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.

Constructors

WordPtr Word |

#### Instances

Instances details

Bits WordPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: WordPtr -> WordPtr -> WordPtr Source #

(.|.) :: WordPtr -> WordPtr -> WordPtr Source #

xor :: WordPtr -> WordPtr -> WordPtr Source #

complement :: WordPtr -> WordPtr Source #

shift :: WordPtr -> Int -> WordPtr Source #

rotate :: WordPtr -> Int -> WordPtr Source #

zeroBits :: WordPtr Source #

bit :: Int -> WordPtr Source #

setBit :: WordPtr -> Int -> WordPtr Source #

clearBit :: WordPtr -> Int -> WordPtr Source #

complementBit :: WordPtr -> Int -> WordPtr Source #

testBit :: WordPtr -> Int -> Bool Source #

bitSizeMaybe :: WordPtr -> Maybe Int Source #

bitSize :: WordPtr -> Int Source #

isSigned :: WordPtr -> Bool Source #

shiftL :: WordPtr -> Int -> WordPtr Source #

unsafeShiftL :: WordPtr -> Int -> WordPtr Source #

shiftR :: WordPtr -> Int -> WordPtr Source #

unsafeShiftR :: WordPtr -> Int -> WordPtr Source #

rotateL :: WordPtr -> Int -> WordPtr Source #

rotateR :: WordPtr -> Int -> WordPtr Source #

popCount :: WordPtr -> Int Source #

FiniteBits WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods finiteBitSize :: WordPtr -> Int Source # countLeadingZeros :: WordPtr -> Int Source # countTrailingZeros :: WordPtr -> Int Source #
Bounded WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods minBound :: WordPtr Source # maxBound :: WordPtr Source #
Enum WordPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

succ :: WordPtr -> WordPtr Source #

pred :: WordPtr -> WordPtr Source #

toEnum :: Int -> WordPtr Source #

fromEnum :: WordPtr -> Int Source #

enumFrom :: WordPtr -> [WordPtr] Source #

enumFromThen :: WordPtr -> WordPtr -> [WordPtr] Source #

enumFromTo :: WordPtr -> WordPtr -> [WordPtr] Source #

enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] Source #

Storable WordPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: WordPtr -> Int Source #

alignment :: WordPtr -> Int Source #

peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr Source #

pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO WordPtr Source #

pokeByteOff :: Ptr b -> Int -> WordPtr -> IO () Source #

peek :: Ptr WordPtr -> IO WordPtr Source #

poke :: Ptr WordPtr -> WordPtr -> IO () Source #

Ix WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods range :: (WordPtr, WordPtr) -> [WordPtr] Source # index :: (WordPtr, WordPtr) -> WordPtr -> Int Source # unsafeIndex :: (WordPtr, WordPtr) -> WordPtr -> Int Source # inRange :: (WordPtr, WordPtr) -> WordPtr -> Bool Source # rangeSize :: (WordPtr, WordPtr) -> Int Source # unsafeRangeSize :: (WordPtr, WordPtr) -> Int Source #
Num WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (+) :: WordPtr -> WordPtr -> WordPtr Source # (-) :: WordPtr -> WordPtr -> WordPtr Source # (*) :: WordPtr -> WordPtr -> WordPtr Source # negate :: WordPtr -> WordPtr Source # abs :: WordPtr -> WordPtr Source # signum :: WordPtr -> WordPtr Source # fromInteger :: Integer -> WordPtr Source #
Read WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods readsPrec :: Int -> ReadS WordPtr Source # readList :: ReadS [WordPtr] Source # readPrec :: ReadPrec WordPtr Source # readListPrec :: ReadPrec [WordPtr] Source #
Integral WordPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

quot :: WordPtr -> WordPtr -> WordPtr Source #

rem :: WordPtr -> WordPtr -> WordPtr Source #

div :: WordPtr -> WordPtr -> WordPtr Source #

mod :: WordPtr -> WordPtr -> WordPtr Source #

quotRem :: WordPtr -> WordPtr -> (WordPtr, WordPtr) Source #

divMod :: WordPtr -> WordPtr -> (WordPtr, WordPtr) Source #

toInteger :: WordPtr -> Integer Source #

Real WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods toRational :: WordPtr -> Rational Source #
Show WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods showsPrec :: Int -> WordPtr -> ShowS Source # show :: WordPtr -> String Source # showList :: [WordPtr] -> ShowS Source #
Eq WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (==) :: WordPtr -> WordPtr -> Bool Source # (/=) :: WordPtr -> WordPtr -> Bool Source #
Ord WordPtr |
Instance details Defined in GHC.Internal.Foreign.Ptr Methods compare :: WordPtr -> WordPtr -> Ordering Source # (<) :: WordPtr -> WordPtr -> Bool Source # (<=) :: WordPtr -> WordPtr -> Bool Source # (>) :: WordPtr -> WordPtr -> Bool Source # (>=) :: WordPtr -> WordPtr -> Bool Source # max :: WordPtr -> WordPtr -> WordPtr Source # min :: WordPtr -> WordPtr -> WordPtr Source #
Hashable WordPtr |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WordPtr -> Int hash :: WordPtr -> Int

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

Instances details

Show (ForeignPtr a) | Since: base-2.1
Instance details Defined in GHC.Internal.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS Source # show :: ForeignPtr a -> String Source # showList :: [ForeignPtr a] -> ShowS Source #
Eq (ForeignPtr a) | Since: base-2.1
Instance details Defined in GHC.Internal.ForeignPtr Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool Source #
Ord (ForeignPtr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

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 either use the `ccall` or the `capi` calling convention.

type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ()) Source #

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

data StablePtr a Source #

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

Instances details

Storable (StablePtr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (StablePtr a) -> IO (StablePtr a) Source #

poke :: Ptr (StablePtr a) -> StablePtr a -> IO () Source #

Eq (StablePtr a) | Since: base-2.1
Instance details Defined in GHC.Internal.Stable Methods (==) :: StablePtr a -> StablePtr a -> Bool Source # (/=) :: StablePtr a -> StablePtr a -> Bool 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 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 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 ``Ptr` a`, for some `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

sizeOf :: a -> Int Source #

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 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 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

Instances details

Storable Fingerprint | Since: base-4.4.0.0

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Fingerprint -> Int Source #

alignment :: Fingerprint -> Int Source #

peekElemOff :: Ptr Fingerprint -> Int -> IO Fingerprint Source #

pokeElemOff :: Ptr Fingerprint -> Int -> Fingerprint -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Fingerprint Source #

pokeByteOff :: Ptr b -> Int -> Fingerprint -> IO () Source #

peek :: Ptr Fingerprint -> IO Fingerprint Source #

poke :: Ptr Fingerprint -> Fingerprint -> IO () Source #

Storable CBool |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CBool -> Int Source #

alignment :: CBool -> Int Source #

peekElemOff :: Ptr CBool -> Int -> IO CBool Source #

pokeElemOff :: Ptr CBool -> Int -> CBool -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CBool Source #

pokeByteOff :: Ptr b -> Int -> CBool -> IO () Source #

peek :: Ptr CBool -> IO CBool Source #

poke :: Ptr CBool -> CBool -> IO () Source #

Storable CChar |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CChar -> Int Source #

alignment :: CChar -> Int Source #

peekElemOff :: Ptr CChar -> Int -> IO CChar Source #

pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CChar Source #

pokeByteOff :: Ptr b -> Int -> CChar -> IO () Source #

peek :: Ptr CChar -> IO CChar Source #

poke :: Ptr CChar -> CChar -> IO () Source #

Storable CClock |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CClock -> Int Source #

alignment :: CClock -> Int Source #

peekElemOff :: Ptr CClock -> Int -> IO CClock Source #

pokeElemOff :: Ptr CClock -> Int -> CClock -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CClock Source #

pokeByteOff :: Ptr b -> Int -> CClock -> IO () Source #

peek :: Ptr CClock -> IO CClock Source #

poke :: Ptr CClock -> CClock -> IO () Source #

Storable CDouble |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CDouble -> Int Source #

alignment :: CDouble -> Int Source #

peekElemOff :: Ptr CDouble -> Int -> IO CDouble Source #

pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CDouble Source #

pokeByteOff :: Ptr b -> Int -> CDouble -> IO () Source #

peek :: Ptr CDouble -> IO CDouble Source #

poke :: Ptr CDouble -> CDouble -> IO () Source #

Storable CFloat |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CFloat -> Int Source #

alignment :: CFloat -> Int Source #

peekElemOff :: Ptr CFloat -> Int -> IO CFloat Source #

pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CFloat Source #

pokeByteOff :: Ptr b -> Int -> CFloat -> IO () Source #

peek :: Ptr CFloat -> IO CFloat Source #

poke :: Ptr CFloat -> CFloat -> IO () Source #

Storable CInt |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CInt -> Int Source #

alignment :: CInt -> Int Source #

peekElemOff :: Ptr CInt -> Int -> IO CInt Source #

pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CInt Source #

pokeByteOff :: Ptr b -> Int -> CInt -> IO () Source #

peek :: Ptr CInt -> IO CInt Source #

poke :: Ptr CInt -> CInt -> IO () Source #

Storable CIntMax |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CIntMax -> Int Source #

alignment :: CIntMax -> Int Source #

peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax Source #

pokeElemOff :: Ptr CIntMax -> Int -> CIntMax -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CIntMax Source #

pokeByteOff :: Ptr b -> Int -> CIntMax -> IO () Source #

peek :: Ptr CIntMax -> IO CIntMax Source #

poke :: Ptr CIntMax -> CIntMax -> IO () Source #

Storable CIntPtr |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CIntPtr -> Int Source #

alignment :: CIntPtr -> Int Source #

peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr Source #

pokeElemOff :: Ptr CIntPtr -> Int -> CIntPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CIntPtr Source #

pokeByteOff :: Ptr b -> Int -> CIntPtr -> IO () Source #

peek :: Ptr CIntPtr -> IO CIntPtr Source #

poke :: Ptr CIntPtr -> CIntPtr -> IO () Source #

Storable CLLong |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CLLong -> Int Source #

alignment :: CLLong -> Int Source #

peekElemOff :: Ptr CLLong -> Int -> IO CLLong Source #

pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CLLong Source #

pokeByteOff :: Ptr b -> Int -> CLLong -> IO () Source #

peek :: Ptr CLLong -> IO CLLong Source #

poke :: Ptr CLLong -> CLLong -> IO () Source #

Storable CLong |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CLong -> Int Source #

alignment :: CLong -> Int Source #

peekElemOff :: Ptr CLong -> Int -> IO CLong Source #

pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CLong Source #

pokeByteOff :: Ptr b -> Int -> CLong -> IO () Source #

peek :: Ptr CLong -> IO CLong Source #

poke :: Ptr CLong -> CLong -> IO () Source #

Storable CPtrdiff |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CPtrdiff -> Int Source #

alignment :: CPtrdiff -> Int Source #

peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff Source #

pokeElemOff :: Ptr CPtrdiff -> Int -> CPtrdiff -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CPtrdiff Source #

pokeByteOff :: Ptr b -> Int -> CPtrdiff -> IO () Source #

peek :: Ptr CPtrdiff -> IO CPtrdiff Source #

poke :: Ptr CPtrdiff -> CPtrdiff -> IO () Source #

Storable CSChar |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CSChar -> Int Source #

alignment :: CSChar -> Int Source #

peekElemOff :: Ptr CSChar -> Int -> IO CSChar Source #

pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSChar Source #

pokeByteOff :: Ptr b -> Int -> CSChar -> IO () Source #

peek :: Ptr CSChar -> IO CSChar Source #

poke :: Ptr CSChar -> CSChar -> IO () Source #

Storable CSUSeconds |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CSUSeconds -> Int Source #

alignment :: CSUSeconds -> Int Source #

peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds Source #

pokeElemOff :: Ptr CSUSeconds -> Int -> CSUSeconds -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSUSeconds Source #

pokeByteOff :: Ptr b -> Int -> CSUSeconds -> IO () Source #

peek :: Ptr CSUSeconds -> IO CSUSeconds Source #

poke :: Ptr CSUSeconds -> CSUSeconds -> IO () Source #

Storable CShort |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CShort -> Int Source #

alignment :: CShort -> Int Source #

peekElemOff :: Ptr CShort -> Int -> IO CShort Source #

pokeElemOff :: Ptr CShort -> Int -> CShort -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CShort Source #

pokeByteOff :: Ptr b -> Int -> CShort -> IO () Source #

peek :: Ptr CShort -> IO CShort Source #

poke :: Ptr CShort -> CShort -> IO () Source #

Storable CSigAtomic |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CSigAtomic -> Int Source #

alignment :: CSigAtomic -> Int Source #

peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic Source #

pokeElemOff :: Ptr CSigAtomic -> Int -> CSigAtomic -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSigAtomic Source #

pokeByteOff :: Ptr b -> Int -> CSigAtomic -> IO () Source #

peek :: Ptr CSigAtomic -> IO CSigAtomic Source #

poke :: Ptr CSigAtomic -> CSigAtomic -> IO () Source #

Storable CSize |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CSize -> Int Source #

alignment :: CSize -> Int Source #

peekElemOff :: Ptr CSize -> Int -> IO CSize Source #

pokeElemOff :: Ptr CSize -> Int -> CSize -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSize Source #

pokeByteOff :: Ptr b -> Int -> CSize -> IO () Source #

peek :: Ptr CSize -> IO CSize Source #

poke :: Ptr CSize -> CSize -> IO () Source #

Storable CTime |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CTime -> Int Source #

alignment :: CTime -> Int Source #

peekElemOff :: Ptr CTime -> Int -> IO CTime Source #

pokeElemOff :: Ptr CTime -> Int -> CTime -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CTime Source #

pokeByteOff :: Ptr b -> Int -> CTime -> IO () Source #

peek :: Ptr CTime -> IO CTime Source #

poke :: Ptr CTime -> CTime -> IO () Source #

Storable CUChar |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUChar -> Int Source #

alignment :: CUChar -> Int Source #

peekElemOff :: Ptr CUChar -> Int -> IO CUChar Source #

pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUChar Source #

pokeByteOff :: Ptr b -> Int -> CUChar -> IO () Source #

peek :: Ptr CUChar -> IO CUChar Source #

poke :: Ptr CUChar -> CUChar -> IO () Source #

Storable CUInt |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUInt -> Int Source #

alignment :: CUInt -> Int Source #

peekElemOff :: Ptr CUInt -> Int -> IO CUInt Source #

pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUInt Source #

pokeByteOff :: Ptr b -> Int -> CUInt -> IO () Source #

peek :: Ptr CUInt -> IO CUInt Source #

poke :: Ptr CUInt -> CUInt -> IO () Source #

Storable CUIntMax |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUIntMax -> Int Source #

alignment :: CUIntMax -> Int Source #

peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax Source #

pokeElemOff :: Ptr CUIntMax -> Int -> CUIntMax -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUIntMax Source #

pokeByteOff :: Ptr b -> Int -> CUIntMax -> IO () Source #

peek :: Ptr CUIntMax -> IO CUIntMax Source #

poke :: Ptr CUIntMax -> CUIntMax -> IO () Source #

Storable CUIntPtr |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUIntPtr -> Int Source #

alignment :: CUIntPtr -> Int Source #

peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr Source #

pokeElemOff :: Ptr CUIntPtr -> Int -> CUIntPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUIntPtr Source #

pokeByteOff :: Ptr b -> Int -> CUIntPtr -> IO () Source #

peek :: Ptr CUIntPtr -> IO CUIntPtr Source #

poke :: Ptr CUIntPtr -> CUIntPtr -> IO () Source #

Storable CULLong |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CULLong -> Int Source #

alignment :: CULLong -> Int Source #

peekElemOff :: Ptr CULLong -> Int -> IO CULLong Source #

pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CULLong Source #

pokeByteOff :: Ptr b -> Int -> CULLong -> IO () Source #

peek :: Ptr CULLong -> IO CULLong Source #

poke :: Ptr CULLong -> CULLong -> IO () Source #

Storable CULong |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CULong -> Int Source #

alignment :: CULong -> Int Source #

peekElemOff :: Ptr CULong -> Int -> IO CULong Source #

pokeElemOff :: Ptr CULong -> Int -> CULong -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CULong Source #

pokeByteOff :: Ptr b -> Int -> CULong -> IO () Source #

peek :: Ptr CULong -> IO CULong Source #

poke :: Ptr CULong -> CULong -> IO () Source #

Storable CUSeconds |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUSeconds -> Int Source #

alignment :: CUSeconds -> Int Source #

peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds Source #

pokeElemOff :: Ptr CUSeconds -> Int -> CUSeconds -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUSeconds Source #

pokeByteOff :: Ptr b -> Int -> CUSeconds -> IO () Source #

peek :: Ptr CUSeconds -> IO CUSeconds Source #

poke :: Ptr CUSeconds -> CUSeconds -> IO () Source #

Storable CUShort |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CUShort -> Int Source #

alignment :: CUShort -> Int Source #

peekElemOff :: Ptr CUShort -> Int -> IO CUShort Source #

pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUShort Source #

pokeByteOff :: Ptr b -> Int -> CUShort -> IO () Source #

peek :: Ptr CUShort -> IO CUShort Source #

poke :: Ptr CUShort -> CUShort -> IO () Source #

Storable CWchar |

Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

sizeOf :: CWchar -> Int Source #

alignment :: CWchar -> Int Source #

peekElemOff :: Ptr CWchar -> Int -> IO CWchar Source #

pokeElemOff :: Ptr CWchar -> Int -> CWchar -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CWchar Source #

pokeByteOff :: Ptr b -> Int -> CWchar -> IO () Source #

peek :: Ptr CWchar -> IO CWchar Source #

poke :: Ptr CWchar -> CWchar -> IO () Source #

Storable IntPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: IntPtr -> Int Source #

alignment :: IntPtr -> Int Source #

peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr Source #

pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO IntPtr Source #

pokeByteOff :: Ptr b -> Int -> IntPtr -> IO () Source #

peek :: Ptr IntPtr -> IO IntPtr Source #

poke :: Ptr IntPtr -> IntPtr -> IO () Source #

Storable WordPtr |

Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: WordPtr -> Int Source #

alignment :: WordPtr -> Int Source #

peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr Source #

pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO WordPtr Source #

pokeByteOff :: Ptr b -> Int -> WordPtr -> IO () Source #

peek :: Ptr WordPtr -> IO WordPtr Source #

poke :: Ptr WordPtr -> WordPtr -> IO () Source #

Storable Int16 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int16 -> Int Source #

alignment :: Int16 -> Int Source #

peekElemOff :: Ptr Int16 -> Int -> IO Int16 Source #

pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Int16 Source #

pokeByteOff :: Ptr b -> Int -> Int16 -> IO () Source #

peek :: Ptr Int16 -> IO Int16 Source #

poke :: Ptr Int16 -> Int16 -> IO () Source #

Storable Int32 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int32 -> Int Source #

alignment :: Int32 -> Int Source #

peekElemOff :: Ptr Int32 -> Int -> IO Int32 Source #

pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Int32 Source #

pokeByteOff :: Ptr b -> Int -> Int32 -> IO () Source #

peek :: Ptr Int32 -> IO Int32 Source #

poke :: Ptr Int32 -> Int32 -> IO () Source #

Storable Int64 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int64 -> Int Source #

alignment :: Int64 -> Int Source #

peekElemOff :: Ptr Int64 -> Int -> IO Int64 Source #

pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Int64 Source #

pokeByteOff :: Ptr b -> Int -> Int64 -> IO () Source #

peek :: Ptr Int64 -> IO Int64 Source #

poke :: Ptr Int64 -> Int64 -> IO () Source #

Storable Int8 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int8 -> Int Source #

alignment :: Int8 -> Int Source #

peekElemOff :: Ptr Int8 -> Int -> IO Int8 Source #

pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Int8 Source #

pokeByteOff :: Ptr b -> Int -> Int8 -> IO () Source #

peek :: Ptr Int8 -> IO Int8 Source #

poke :: Ptr Int8 -> Int8 -> IO () Source #

Storable IoSubSystem | Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.RTS.Flags

Methods

sizeOf :: IoSubSystem -> Int Source #

alignment :: IoSubSystem -> Int Source #

peekElemOff :: Ptr IoSubSystem -> Int -> IO IoSubSystem Source #

pokeElemOff :: Ptr IoSubSystem -> Int -> IoSubSystem -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO IoSubSystem Source #

pokeByteOff :: Ptr b -> Int -> IoSubSystem -> IO () Source #

peek :: Ptr IoSubSystem -> IO IoSubSystem Source #

poke :: Ptr IoSubSystem -> IoSubSystem -> IO () Source #

Storable CBlkCnt |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CBlkCnt -> Int Source #

alignment :: CBlkCnt -> Int Source #

peekElemOff :: Ptr CBlkCnt -> Int -> IO CBlkCnt Source #

pokeElemOff :: Ptr CBlkCnt -> Int -> CBlkCnt -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CBlkCnt Source #

pokeByteOff :: Ptr b -> Int -> CBlkCnt -> IO () Source #

peek :: Ptr CBlkCnt -> IO CBlkCnt Source #

poke :: Ptr CBlkCnt -> CBlkCnt -> IO () Source #

Storable CBlkSize |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CBlkSize -> Int Source #

alignment :: CBlkSize -> Int Source #

peekElemOff :: Ptr CBlkSize -> Int -> IO CBlkSize Source #

pokeElemOff :: Ptr CBlkSize -> Int -> CBlkSize -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CBlkSize Source #

pokeByteOff :: Ptr b -> Int -> CBlkSize -> IO () Source #

peek :: Ptr CBlkSize -> IO CBlkSize Source #

poke :: Ptr CBlkSize -> CBlkSize -> IO () Source #

Storable CCc |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CCc -> Int Source #

alignment :: CCc -> Int Source #

peekElemOff :: Ptr CCc -> Int -> IO CCc Source #

pokeElemOff :: Ptr CCc -> Int -> CCc -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CCc Source #

pokeByteOff :: Ptr b -> Int -> CCc -> IO () Source #

peek :: Ptr CCc -> IO CCc Source #

poke :: Ptr CCc -> CCc -> IO () Source #

Storable CClockId |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CClockId -> Int Source #

alignment :: CClockId -> Int Source #

peekElemOff :: Ptr CClockId -> Int -> IO CClockId Source #

pokeElemOff :: Ptr CClockId -> Int -> CClockId -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CClockId Source #

pokeByteOff :: Ptr b -> Int -> CClockId -> IO () Source #

peek :: Ptr CClockId -> IO CClockId Source #

poke :: Ptr CClockId -> CClockId -> IO () Source #

Storable CDev |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CDev -> Int Source #

alignment :: CDev -> Int Source #

peekElemOff :: Ptr CDev -> Int -> IO CDev Source #

pokeElemOff :: Ptr CDev -> Int -> CDev -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CDev Source #

pokeByteOff :: Ptr b -> Int -> CDev -> IO () Source #

peek :: Ptr CDev -> IO CDev Source #

poke :: Ptr CDev -> CDev -> IO () Source #

Storable CFsBlkCnt |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CFsBlkCnt -> Int Source #

alignment :: CFsBlkCnt -> Int Source #

peekElemOff :: Ptr CFsBlkCnt -> Int -> IO CFsBlkCnt Source #

pokeElemOff :: Ptr CFsBlkCnt -> Int -> CFsBlkCnt -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CFsBlkCnt Source #

pokeByteOff :: Ptr b -> Int -> CFsBlkCnt -> IO () Source #

peek :: Ptr CFsBlkCnt -> IO CFsBlkCnt Source #

poke :: Ptr CFsBlkCnt -> CFsBlkCnt -> IO () Source #

Storable CFsFilCnt |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CFsFilCnt -> Int Source #

alignment :: CFsFilCnt -> Int Source #

peekElemOff :: Ptr CFsFilCnt -> Int -> IO CFsFilCnt Source #

pokeElemOff :: Ptr CFsFilCnt -> Int -> CFsFilCnt -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CFsFilCnt Source #

pokeByteOff :: Ptr b -> Int -> CFsFilCnt -> IO () Source #

peek :: Ptr CFsFilCnt -> IO CFsFilCnt Source #

poke :: Ptr CFsFilCnt -> CFsFilCnt -> IO () Source #

Storable CGid |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CGid -> Int Source #

alignment :: CGid -> Int Source #

peekElemOff :: Ptr CGid -> Int -> IO CGid Source #

pokeElemOff :: Ptr CGid -> Int -> CGid -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CGid Source #

pokeByteOff :: Ptr b -> Int -> CGid -> IO () Source #

peek :: Ptr CGid -> IO CGid Source #

poke :: Ptr CGid -> CGid -> IO () Source #

Storable CId |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CId -> Int Source #

alignment :: CId -> Int Source #

peekElemOff :: Ptr CId -> Int -> IO CId Source #

pokeElemOff :: Ptr CId -> Int -> CId -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CId Source #

pokeByteOff :: Ptr b -> Int -> CId -> IO () Source #

peek :: Ptr CId -> IO CId Source #

poke :: Ptr CId -> CId -> IO () Source #

Storable CIno |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CIno -> Int Source #

alignment :: CIno -> Int Source #

peekElemOff :: Ptr CIno -> Int -> IO CIno Source #

pokeElemOff :: Ptr CIno -> Int -> CIno -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CIno Source #

pokeByteOff :: Ptr b -> Int -> CIno -> IO () Source #

peek :: Ptr CIno -> IO CIno Source #

poke :: Ptr CIno -> CIno -> IO () Source #

Storable CKey |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CKey -> Int Source #

alignment :: CKey -> Int Source #

peekElemOff :: Ptr CKey -> Int -> IO CKey Source #

pokeElemOff :: Ptr CKey -> Int -> CKey -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CKey Source #

pokeByteOff :: Ptr b -> Int -> CKey -> IO () Source #

peek :: Ptr CKey -> IO CKey Source #

poke :: Ptr CKey -> CKey -> IO () Source #

Storable CMode |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CMode -> Int Source #

alignment :: CMode -> Int Source #

peekElemOff :: Ptr CMode -> Int -> IO CMode Source #

pokeElemOff :: Ptr CMode -> Int -> CMode -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CMode Source #

pokeByteOff :: Ptr b -> Int -> CMode -> IO () Source #

peek :: Ptr CMode -> IO CMode Source #

poke :: Ptr CMode -> CMode -> IO () Source #

Storable CNfds |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CNfds -> Int Source #

alignment :: CNfds -> Int Source #

peekElemOff :: Ptr CNfds -> Int -> IO CNfds Source #

pokeElemOff :: Ptr CNfds -> Int -> CNfds -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CNfds Source #

pokeByteOff :: Ptr b -> Int -> CNfds -> IO () Source #

peek :: Ptr CNfds -> IO CNfds Source #

poke :: Ptr CNfds -> CNfds -> IO () Source #

Storable CNlink |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CNlink -> Int Source #

alignment :: CNlink -> Int Source #

peekElemOff :: Ptr CNlink -> Int -> IO CNlink Source #

pokeElemOff :: Ptr CNlink -> Int -> CNlink -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CNlink Source #

pokeByteOff :: Ptr b -> Int -> CNlink -> IO () Source #

peek :: Ptr CNlink -> IO CNlink Source #

poke :: Ptr CNlink -> CNlink -> IO () Source #

Storable COff |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: COff -> Int Source #

alignment :: COff -> Int Source #

peekElemOff :: Ptr COff -> Int -> IO COff Source #

pokeElemOff :: Ptr COff -> Int -> COff -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO COff Source #

pokeByteOff :: Ptr b -> Int -> COff -> IO () Source #

peek :: Ptr COff -> IO COff Source #

poke :: Ptr COff -> COff -> IO () Source #

Storable CPid |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CPid -> Int Source #

alignment :: CPid -> Int Source #

peekElemOff :: Ptr CPid -> Int -> IO CPid Source #

pokeElemOff :: Ptr CPid -> Int -> CPid -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CPid Source #

pokeByteOff :: Ptr b -> Int -> CPid -> IO () Source #

peek :: Ptr CPid -> IO CPid Source #

poke :: Ptr CPid -> CPid -> IO () Source #

Storable CRLim |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CRLim -> Int Source #

alignment :: CRLim -> Int Source #

peekElemOff :: Ptr CRLim -> Int -> IO CRLim Source #

pokeElemOff :: Ptr CRLim -> Int -> CRLim -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CRLim Source #

pokeByteOff :: Ptr b -> Int -> CRLim -> IO () Source #

peek :: Ptr CRLim -> IO CRLim Source #

poke :: Ptr CRLim -> CRLim -> IO () Source #

Storable CSocklen |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSocklen -> Int Source #

alignment :: CSocklen -> Int Source #

peekElemOff :: Ptr CSocklen -> Int -> IO CSocklen Source #

pokeElemOff :: Ptr CSocklen -> Int -> CSocklen -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSocklen Source #

pokeByteOff :: Ptr b -> Int -> CSocklen -> IO () Source #

peek :: Ptr CSocklen -> IO CSocklen Source #

poke :: Ptr CSocklen -> CSocklen -> IO () Source #

Storable CSpeed |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSpeed -> Int Source #

alignment :: CSpeed -> Int Source #

peekElemOff :: Ptr CSpeed -> Int -> IO CSpeed Source #

pokeElemOff :: Ptr CSpeed -> Int -> CSpeed -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSpeed Source #

pokeByteOff :: Ptr b -> Int -> CSpeed -> IO () Source #

peek :: Ptr CSpeed -> IO CSpeed Source #

poke :: Ptr CSpeed -> CSpeed -> IO () Source #

Storable CSsize |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSsize -> Int Source #

alignment :: CSsize -> Int Source #

peekElemOff :: Ptr CSsize -> Int -> IO CSsize Source #

pokeElemOff :: Ptr CSsize -> Int -> CSsize -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CSsize Source #

pokeByteOff :: Ptr b -> Int -> CSsize -> IO () Source #

peek :: Ptr CSsize -> IO CSsize Source #

poke :: Ptr CSsize -> CSsize -> IO () Source #

Storable CTcflag |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CTcflag -> Int Source #

alignment :: CTcflag -> Int Source #

peekElemOff :: Ptr CTcflag -> Int -> IO CTcflag Source #

pokeElemOff :: Ptr CTcflag -> Int -> CTcflag -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CTcflag Source #

pokeByteOff :: Ptr b -> Int -> CTcflag -> IO () Source #

peek :: Ptr CTcflag -> IO CTcflag Source #

poke :: Ptr CTcflag -> CTcflag -> IO () Source #

Storable CTimer |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CTimer -> Int Source #

alignment :: CTimer -> Int Source #

peekElemOff :: Ptr CTimer -> Int -> IO CTimer Source #

pokeElemOff :: Ptr CTimer -> Int -> CTimer -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CTimer Source #

pokeByteOff :: Ptr b -> Int -> CTimer -> IO () Source #

peek :: Ptr CTimer -> IO CTimer Source #

poke :: Ptr CTimer -> CTimer -> IO () Source #

Storable CUid |

Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CUid -> Int Source #

alignment :: CUid -> Int Source #

peekElemOff :: Ptr CUid -> Int -> IO CUid Source #

pokeElemOff :: Ptr CUid -> Int -> CUid -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CUid Source #

pokeByteOff :: Ptr b -> Int -> CUid -> IO () Source #

peek :: Ptr CUid -> IO CUid Source #

poke :: Ptr CUid -> CUid -> IO () Source #

Storable Fd |
Instance details Defined in GHC.Internal.System.Posix.Types Methods sizeOf :: Fd -> Int Source # alignment :: Fd -> Int Source # peekElemOff :: Ptr Fd -> Int -> IO Fd Source # pokeElemOff :: Ptr Fd -> Int -> Fd -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Fd Source # pokeByteOff :: Ptr b -> Int -> Fd -> IO () Source # peek :: Ptr Fd -> IO Fd Source # poke :: Ptr Fd -> Fd -> IO () Source #
Storable Word16 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word16 -> Int Source #

alignment :: Word16 -> Int Source #

peekElemOff :: Ptr Word16 -> Int -> IO Word16 Source #

pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Word16 Source #

pokeByteOff :: Ptr b -> Int -> Word16 -> IO () Source #

peek :: Ptr Word16 -> IO Word16 Source #

poke :: Ptr Word16 -> Word16 -> IO () Source #

Storable Word32 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word32 -> Int Source #

alignment :: Word32 -> Int Source #

peekElemOff :: Ptr Word32 -> Int -> IO Word32 Source #

pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Word32 Source #

pokeByteOff :: Ptr b -> Int -> Word32 -> IO () Source #

peek :: Ptr Word32 -> IO Word32 Source #

poke :: Ptr Word32 -> Word32 -> IO () Source #

Storable Word64 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word64 -> Int Source #

alignment :: Word64 -> Int Source #

peekElemOff :: Ptr Word64 -> Int -> IO Word64 Source #

pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Word64 Source #

pokeByteOff :: Ptr b -> Int -> Word64 -> IO () Source #

peek :: Ptr Word64 -> IO Word64 Source #

poke :: Ptr Word64 -> Word64 -> IO () Source #

Storable Word8 | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word8 -> Int Source #

alignment :: Word8 -> Int Source #

peekElemOff :: Ptr Word8 -> Int -> IO Word8 Source #

pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Word8 Source #

pokeByteOff :: Ptr b -> Int -> Word8 -> IO () Source #

peek :: Ptr Word8 -> IO Word8 Source #

poke :: Ptr Word8 -> Word8 -> IO () Source #

Storable CAttributes |

Instance details

Defined in System.Posix.Files.Common

Methods

sizeOf :: CAttributes -> Int Source #

alignment :: CAttributes -> Int Source #

peekElemOff :: Ptr CAttributes -> Int -> IO CAttributes Source #

pokeElemOff :: Ptr CAttributes -> Int -> CAttributes -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CAttributes Source #

pokeByteOff :: Ptr b -> Int -> CAttributes -> IO () Source #

peek :: Ptr CAttributes -> IO CAttributes Source #

poke :: Ptr CAttributes -> CAttributes -> IO () Source #

Storable CTimeSpec |

Instance details

Defined in System.Posix.Files.Common

Methods

sizeOf :: CTimeSpec -> Int Source #

alignment :: CTimeSpec -> Int Source #

peekElemOff :: Ptr CTimeSpec -> Int -> IO CTimeSpec Source #

pokeElemOff :: Ptr CTimeSpec -> Int -> CTimeSpec -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CTimeSpec Source #

pokeByteOff :: Ptr b -> Int -> CTimeSpec -> IO () Source #

peek :: Ptr CTimeSpec -> IO CTimeSpec Source #

poke :: Ptr CTimeSpec -> CTimeSpec -> IO () Source #

Storable CTimeVal |

Instance details

Defined in System.Posix.Files.Common

Methods

sizeOf :: CTimeVal -> Int Source #

alignment :: CTimeVal -> Int Source #

peekElemOff :: Ptr CTimeVal -> Int -> IO CTimeVal Source #

pokeElemOff :: Ptr CTimeVal -> Int -> CTimeVal -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO CTimeVal Source #

pokeByteOff :: Ptr b -> Int -> CTimeVal -> IO () Source #

peek :: Ptr CTimeVal -> IO CTimeVal Source #

poke :: Ptr CTimeVal -> CTimeVal -> IO () Source #

Storable () | Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: () -> Int Source # alignment :: () -> Int Source # peekElemOff :: Ptr () -> Int -> IO () Source # pokeElemOff :: Ptr () -> Int -> () -> IO () Source # peekByteOff :: Ptr b -> Int -> IO () Source # pokeByteOff :: Ptr b -> Int -> () -> IO () Source # peek :: Ptr () -> IO () Source # poke :: Ptr () -> () -> IO () Source #
Storable Bool | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Bool -> Int Source #

alignment :: Bool -> Int Source #

peekElemOff :: Ptr Bool -> Int -> IO Bool Source #

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Bool Source #

pokeByteOff :: Ptr b -> Int -> Bool -> IO () Source #

peek :: Ptr Bool -> IO Bool Source #

poke :: Ptr Bool -> Bool -> IO () Source #

Storable Char | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Char -> Int Source #

alignment :: Char -> Int Source #

peekElemOff :: Ptr Char -> Int -> IO Char Source #

pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Char Source #

pokeByteOff :: Ptr b -> Int -> Char -> IO () Source #

peek :: Ptr Char -> IO Char Source #

poke :: Ptr Char -> Char -> IO () Source #

Storable Double | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Double -> Int Source #

alignment :: Double -> Int Source #

peekElemOff :: Ptr Double -> Int -> IO Double Source #

pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Double Source #

pokeByteOff :: Ptr b -> Int -> Double -> IO () Source #

peek :: Ptr Double -> IO Double Source #

poke :: Ptr Double -> Double -> IO () Source #

Storable Float | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Float -> Int Source #

alignment :: Float -> Int Source #

peekElemOff :: Ptr Float -> Int -> IO Float Source #

pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Float Source #

pokeByteOff :: Ptr b -> Int -> Float -> IO () Source #

peek :: Ptr Float -> IO Float Source #

poke :: Ptr Float -> Float -> IO () Source #

Storable Int | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int -> Int Source #

alignment :: Int -> Int Source #

peekElemOff :: Ptr Int -> Int -> IO Int Source #

pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Int Source #

pokeByteOff :: Ptr b -> Int -> Int -> IO () Source #

peek :: Ptr Int -> IO Int Source #

poke :: Ptr Int -> Int -> IO () Source #

Storable Word | Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word -> Int Source #

alignment :: Word -> Int Source #

peekElemOff :: Ptr Word -> Int -> IO Word Source #

pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO Word Source #

pokeByteOff :: Ptr b -> Int -> Word -> IO () Source #

peek :: Ptr Word -> IO Word Source #

poke :: Ptr Word -> Word -> IO () Source #

Storable a => Storable (Complex a) | Since: base-4.8.0.0

Instance details

Defined in Data.Complex

Methods

sizeOf :: Complex a -> Int Source #

alignment :: Complex a -> Int Source #

peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) Source #

pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO (Complex a) Source #

pokeByteOff :: Ptr b -> Int -> Complex a -> IO () Source #

peek :: Ptr (Complex a) -> IO (Complex a) Source #

poke :: Ptr (Complex a) -> Complex a -> IO () Source #

Storable a => Storable (Identity a) | Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Functor.Identity

Methods

sizeOf :: Identity a -> Int Source #

alignment :: Identity a -> Int Source #

peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) Source #

pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO (Identity a) Source #

pokeByteOff :: Ptr b -> Int -> Identity a -> IO () Source #

peek :: Ptr (Identity a) -> IO (Identity a) Source #

poke :: Ptr (Identity a) -> Identity a -> IO () Source #

Storable (ConstPtr a) |

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: ConstPtr a -> Int Source #

alignment :: ConstPtr a -> Int Source #

peekElemOff :: Ptr (ConstPtr a) -> Int -> IO (ConstPtr a) Source #

pokeElemOff :: Ptr (ConstPtr a) -> Int -> ConstPtr a -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO (ConstPtr a) Source #

pokeByteOff :: Ptr b -> Int -> ConstPtr a -> IO () Source #

peek :: Ptr (ConstPtr a) -> IO (ConstPtr a) Source #

poke :: Ptr (ConstPtr a) -> ConstPtr a -> IO () Source #

Storable (FunPtr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (FunPtr a) -> IO (FunPtr a) Source #

poke :: Ptr (FunPtr a) -> FunPtr a -> IO () Source #

Storable (Ptr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (Ptr a) -> IO (Ptr a) Source #

poke :: Ptr (Ptr a) -> Ptr a -> IO () Source #

(Storable a, Integral a) => Storable (Ratio a) | Since: base-4.8.0.0

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Ratio a -> Int Source #

alignment :: Ratio a -> Int Source #

peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) Source #

pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () Source #

peekByteOff :: Ptr b -> Int -> IO (Ratio a) Source #

pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () Source #

peek :: Ptr (Ratio a) -> IO (Ratio a) Source #

poke :: Ptr (Ratio a) -> Ratio a -> IO () Source #

Storable (StablePtr a) | Since: base-2.1

Instance details

Defined in GHC.Internal.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 #

peek :: Ptr (StablePtr a) -> IO (StablePtr a) Source #

poke :: Ptr (StablePtr a) -> StablePtr a -> IO () Source #

Storable a => Storable (Const a b) | Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Functor.Const

Methods

sizeOf :: Const a b -> Int Source #

alignment :: Const a b -> Int Source #

peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) Source #

pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () Source #

peekByteOff :: Ptr b0 -> Int -> IO (Const a b) Source #

pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source #

peek :: Ptr (Const a b) -> IO (Const a b) Source #

poke :: Ptr (Const a b) -> Const a b -> IO () Source #

# 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

malloc :: (MonadIO m, Storable a) => m (Ptr a) Source #

Lifted `malloc`.

Since: 0.2.5.0

mallocBytes :: MonadIO m => Int -> m (Ptr a) Source #

Lifted `mallocBytes`.

Since: 0.2.5.0

calloc :: (MonadIO m, Storable a) => m (Ptr a) Source #

Lifted `calloc`.

Since: 0.2.5.0

callocBytes :: MonadIO m => Int -> m (Ptr a) Source #

Lifted `callocBytes`.

Since: 0.2.5.0

realloc :: (MonadIO m, Storable b) => Ptr a -> m (Ptr b) Source #

Lifted `realloc`.

Since: 0.2.5.0

reallocBytes :: MonadIO m => Ptr a -> Int -> m (Ptr a) Source #

Lifted `reallocBytes`.

Since: 0.2.5.0

free :: MonadIO m => Ptr a -> m () Source #

Lifted `free`.

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

newArray :: (MonadIO m, Storable a) => [a] -> m (Ptr a) Source #

Lifted `newArray`.

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

data Pool Source #

A memory pool.

newPool :: MonadIO m => m Pool Source #

Lifted `newPool`.

Since: 0.2.5.0

freePool :: MonadIO m => Pool -> m () Source #

Lifted `freePool`.

Since: 0.2.5.0

withPool :: MonadUnliftIO m => (Pool -> m b) -> m b Source #

Unlifted `withPool`.

Since: 0.2.5.0

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

new :: (MonadIO m, Storable a) => a -> m (Ptr a) Source #

Lifted `new`.

Since: 0.2.5.0

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

Convert a Haskell `Bool` to its numeric representation

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

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

Replicates a `withXXX` combinator over a list of objects, yielding a list of marshalled objects

copyBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m () Source #

Lifted `copyBytes`.

Since: 0.2.5.0

moveBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m () Source #

Lifted `moveBytes`.

Since: 0.2.5.0

fillBytes :: MonadIO m => Ptr a -> Word8 -> Int -> m () Source #

Lifted `fillBytes`.

Since: 0.2.5.0