Copyright	(c) The FFI task force 2001
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	ffi@haskell.org
Stability	provisional
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Foreign.Ptr

Contents

Description

This module provides typed pointers to foreign data. It is part of the Foreign Function Interface (FFI) and will normally be imported via theForeign module.

Synopsis

Data pointers

dataPtr aSource #

A value of typePtr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of typea.

The typea will often be an instance of classStorable 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 Cstruct.

Instances

Generic1 (URec (Ptr ()) :: k ->Type)Source #
Instance details Defined inGHC.Generics Associated Types typeRep1 (URec (Ptr ())) :: k ->Type Source # Methods from1 ::URec (Ptr ()) a ->Rep1 (URec (Ptr ())) aSource # to1 ::Rep1 (URec (Ptr ())) a ->URec (Ptr ()) aSource #
Eq (Ptr a)Source #	Since: 2.1
Instance details Defined inGHC.Ptr Methods (==) ::Ptr a ->Ptr a ->Bool # (/=) ::Ptr a ->Ptr a ->Bool #
Data a =>Data (Ptr a)Source #	Since: 4.8.0.0
Instance details Defined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Ptr a -> c (Ptr a)Source # gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Ptr a)Source # toConstr ::Ptr a ->Constr Source # dataTypeOf ::Ptr a ->DataType Source # dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Ptr a))Source # dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Ptr a))Source # gmapT :: (forall b.Data b => b -> b) ->Ptr a ->Ptr aSource # gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Ptr a -> rSource # gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Ptr a -> rSource # gmapQ :: (forall d.Data d => d -> u) ->Ptr a -> [u]Source # gmapQi ::Int -> (forall d.Data d => d -> u) ->Ptr a -> uSource # gmapM ::Monad m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source # gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source # gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source #
Ord (Ptr a)Source #	Since: 2.1
Instance details Defined inGHC.Ptr Methods compare ::Ptr a ->Ptr a ->Ordering # (<) ::Ptr a ->Ptr a ->Bool # (<=) ::Ptr a ->Ptr a ->Bool # (>) ::Ptr a ->Ptr a ->Bool # (>=) ::Ptr a ->Ptr a ->Bool # max ::Ptr a ->Ptr a ->Ptr a# min ::Ptr a ->Ptr a ->Ptr a#
Show (Ptr a)Source #	Since: 2.1
Instance details Defined inGHC.Ptr Methods showsPrec ::Int ->Ptr a ->ShowS Source # show ::Ptr a ->String Source # showList :: [Ptr a] ->ShowS Source #
Storable (Ptr a)Source #	Since: 2.1
Instance details Defined inForeign.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 #
Functor (URec (Ptr ()) ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inGHC.Generics Methods fmap :: (a -> b) ->URec (Ptr ()) a ->URec (Ptr ()) bSource # (<$) :: a ->URec (Ptr ()) b ->URec (Ptr ()) aSource #
Foldable (URec (Ptr ()) ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Foldable Methods fold ::Monoid m =>URec (Ptr ()) m -> mSource # foldMap ::Monoid m => (a -> m) ->URec (Ptr ()) a -> mSource # foldr :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource # foldr' :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource # foldl :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource # foldl' :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource # foldr1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource # foldl1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource # toList ::URec (Ptr ()) a -> [a]Source # null ::URec (Ptr ()) a ->Bool Source # length ::URec (Ptr ()) a ->Int Source # elem ::Eq a => a ->URec (Ptr ()) a ->Bool Source # maximum ::Ord a =>URec (Ptr ()) a -> aSource # minimum ::Ord a =>URec (Ptr ()) a -> aSource # sum ::Num a =>URec (Ptr ()) a -> aSource # product ::Num a =>URec (Ptr ()) a -> aSource #
Traversable (URec (Ptr ()) ::Type ->Type)Source #	Since: 4.9.0.0
Instance details Defined inData.Traversable Methods traverse ::Applicative f => (a -> f b) ->URec (Ptr ()) a -> f (URec (Ptr ()) b)Source # sequenceA ::Applicative f =>URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)Source # mapM ::Monad m => (a -> m b) ->URec (Ptr ()) a -> m (URec (Ptr ()) b)Source # sequence ::Monad m =>URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)Source #
Eq (URec (Ptr ()) p)Source #	Since: 4.9.0.0
Instance details Defined inGHC.Generics Methods (==) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool # (/=) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool #
Ord (URec (Ptr ()) p)Source #	Since: 4.9.0.0
Instance details Defined inGHC.Generics Methods compare ::URec (Ptr ()) p ->URec (Ptr ()) p ->Ordering # (<) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool # (<=) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool # (>) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool # (>=) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool # max ::URec (Ptr ()) p ->URec (Ptr ()) p ->URec (Ptr ()) p# min ::URec (Ptr ()) p ->URec (Ptr ()) p ->URec (Ptr ()) p#
Generic (URec (Ptr ()) p)Source #
Instance details Defined inGHC.Generics Associated Types typeRep (URec (Ptr ()) p) ::Type ->Type Source # Methods from ::URec (Ptr ()) p ->Rep (URec (Ptr ()) p) xSource # to ::Rep (URec (Ptr ()) p) x ->URec (Ptr ()) pSource #
dataURec (Ptr ()) (p :: k)Source #	Used for marking occurrences of`Addr#` Since: 4.9.0.0
Instance details Defined inGHC.Generics dataURec (Ptr ()) (p :: k) =UAddr { uAddr# ::Addr# }
typeRep1 (URec (Ptr ()) :: k ->Type)Source #	Since: 4.9.0.0
Instance details Defined inGHC.Generics typeRep1 (URec (Ptr ()) :: k ->Type) =D1 (MetaData "URec" "GHC.Generics" "base"False) (C1 (MetaCons "UAddr"PrefixI True) (S1 (MetaSel (Just "uAddr#")NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr :: k ->Type)))
typeRep (URec (Ptr ()) p)Source #	Since: 4.9.0.0
Instance details Defined inGHC.Generics typeRep (URec (Ptr ()) p) =D1 (MetaData "URec" "GHC.Generics" "base"False) (C1 (MetaCons "UAddr"PrefixI True) (S1 (MetaSel (Just "uAddr#")NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr ::Type ->Type)))

nullPtr ::Ptr aSource #

The constantnullPtr contains a distinguished value ofPtr that is not associated with a valid memory location.

castPtr ::Ptr a ->Ptr bSource #

ThecastPtr function casts a pointer from one type to another.

plusPtr ::Ptr a ->Int ->Ptr bSource #

Advances the given address by the given offset in bytes.

alignPtr ::Ptr a ->Int ->Ptr aSource #

Given an arbitrary address and an alignment constraint,alignPtr yields the next higher address that fulfills the alignment constraint. An alignment constraintx is fulfilled by any address divisible byx. 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)

Function pointers

dataFunPtr aSource #

A value of typeFunPtr a is a pointer to a function callable from foreign code. The typea will normally be aforeign type, a function type with zero or more arguments where

the argument types aremarshallable 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 usingnewtype.
the return type is either a marshallable foreign type or has the formIO t wheret is a marshallable foreign type or().

A value of typeFunPtr 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 awrapper stub declared to produce aFunPtr of the correct type. For example:

type Compare = Int -> Int -> Boolforeign import ccall "wrapper"  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs likemkCompare allocate storage, which should be released withfreeHaskellFunPtr when no longer required.

To convertFunPtr values to corresponding Haskell functions, one can define adynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()foreign import ccall "dynamic"  mkFun :: FunPtr IntFunction -> IntFunction

Instances

Eq (FunPtr a)Source #
Instance details Defined inGHC.Ptr Methods (==) ::FunPtr a ->FunPtr a ->Bool # (/=) ::FunPtr a ->FunPtr a ->Bool #
Ord (FunPtr a)Source #
Instance details Defined inGHC.Ptr Methods compare ::FunPtr a ->FunPtr a ->Ordering # (<) ::FunPtr a ->FunPtr a ->Bool # (<=) ::FunPtr a ->FunPtr a ->Bool # (>) ::FunPtr a ->FunPtr a ->Bool # (>=) ::FunPtr a ->FunPtr a ->Bool # max ::FunPtr a ->FunPtr a ->FunPtr a# min ::FunPtr a ->FunPtr a ->FunPtr a#
Show (FunPtr a)Source #	Since: 2.1
Instance details Defined inGHC.Ptr Methods showsPrec ::Int ->FunPtr a ->ShowS Source # show ::FunPtr a ->String Source # showList :: [FunPtr a] ->ShowS Source #
Storable (FunPtr a)Source #	Since: 2.1
Instance details Defined inForeign.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 #

nullFunPtr ::FunPtr aSource #

The constantnullFunPtr contains a distinguished value ofFunPtr that is not associated with a valid memory location.

castFunPtr ::FunPtr a ->FunPtr bSource #

Casts aFunPtr to aFunPtr of a different type.

castFunPtrToPtr ::FunPtr a ->Ptr bSource #

Casts aFunPtr to aPtr.

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

Casts aPtr to aFunPtr.

freeHaskellFunPtr ::FunPtr a ->IO ()Source #

Release the storage associated with the givenFunPtr, which must have been obtained from a wrapper stub. This should be called whenever the return value from a foreign import wrapper function is no longer required; otherwise, the storage it uses will leak.

Integral types with lossless conversion to and from pointers

newtypeIntPtr Source #

A signed integral type that can be losslessly converted to and fromPtr. This type is also compatible with the C99 typeintptr_t, and can be marshalled to and from that type safely.

Constructors

IntPtr Int

Instances

Bounded IntPtrSource #
Instance details Defined inForeign.Ptr Methods minBound ::IntPtr Source # maxBound ::IntPtr Source #
Enum IntPtrSource #
Instance details Defined inForeign.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 #
Eq IntPtrSource #
Instance details Defined inForeign.Ptr Methods (==) ::IntPtr ->IntPtr ->Bool # (/=) ::IntPtr ->IntPtr ->Bool #
Integral IntPtrSource #
Instance details Defined inForeign.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 #
Data IntPtrSource #	Since: 4.11.0.0
Instance details Defined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->IntPtr -> cIntPtr Source # gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cIntPtr Source # toConstr ::IntPtr ->Constr Source # dataTypeOf ::IntPtr ->DataType Source # dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cIntPtr)Source # dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cIntPtr)Source # gmapT :: (forall b.Data b => b -> b) ->IntPtr ->IntPtr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->IntPtr -> rSource # gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->IntPtr -> rSource # gmapQ :: (forall d.Data d => d -> u) ->IntPtr -> [u]Source # gmapQi ::Int -> (forall d.Data d => d -> u) ->IntPtr -> uSource # gmapM ::Monad m => (forall d.Data d => d -> m d) ->IntPtr -> mIntPtr Source # gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->IntPtr -> mIntPtr Source # gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->IntPtr -> mIntPtr Source #
Num IntPtrSource #
Instance details Defined inForeign.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 #
Ord IntPtrSource #
Instance details Defined inForeign.Ptr Methods compare ::IntPtr ->IntPtr ->Ordering # (<) ::IntPtr ->IntPtr ->Bool # (<=) ::IntPtr ->IntPtr ->Bool # (>) ::IntPtr ->IntPtr ->Bool # (>=) ::IntPtr ->IntPtr ->Bool # max ::IntPtr ->IntPtr ->IntPtr # min ::IntPtr ->IntPtr ->IntPtr #
Read IntPtrSource #
Instance details Defined inForeign.Ptr Methods readsPrec ::Int ->ReadS IntPtr Source # readList ::ReadS [IntPtr]Source # readPrec ::ReadPrec IntPtr Source # readListPrec ::ReadPrec [IntPtr]Source #
Real IntPtrSource #
Instance details Defined inForeign.Ptr Methods toRational ::IntPtr ->Rational Source #
Show IntPtrSource #
Instance details Defined inForeign.Ptr Methods showsPrec ::Int ->IntPtr ->ShowS Source # show ::IntPtr ->String Source # showList :: [IntPtr] ->ShowS Source #
FiniteBits IntPtrSource #
Instance details Defined inForeign.Ptr Methods finiteBitSize ::IntPtr ->Int Source # countLeadingZeros ::IntPtr ->Int Source # countTrailingZeros ::IntPtr ->Int Source #
Bits IntPtrSource #
Instance details Defined inForeign.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 #
Storable IntPtrSource #
Instance details Defined inForeign.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 #

ptrToIntPtr ::Ptr a ->IntPtr Source #

casts aPtr to anIntPtr

intPtrToPtr ::IntPtr ->Ptr aSource #

casts anIntPtr to aPtr

newtypeWordPtr Source #

An unsigned integral type that can be losslessly converted to and fromPtr. This type is also compatible with the C99 typeuintptr_t, and can be marshalled to and from that type safely.

Constructors

WordPtr Word

Instances

Bounded WordPtrSource #
Instance details Defined inForeign.Ptr Methods minBound ::WordPtr Source # maxBound ::WordPtr Source #
Enum WordPtrSource #
Instance details Defined inForeign.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 #
Eq WordPtrSource #
Instance details Defined inForeign.Ptr Methods (==) ::WordPtr ->WordPtr ->Bool # (/=) ::WordPtr ->WordPtr ->Bool #
Integral WordPtrSource #
Instance details Defined inForeign.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 #
Data WordPtrSource #	Since: 4.11.0.0
Instance details Defined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->WordPtr -> cWordPtr Source # gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cWordPtr Source # toConstr ::WordPtr ->Constr Source # dataTypeOf ::WordPtr ->DataType Source # dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cWordPtr)Source # dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cWordPtr)Source # gmapT :: (forall b.Data b => b -> b) ->WordPtr ->WordPtr Source # gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->WordPtr -> rSource # gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->WordPtr -> rSource # gmapQ :: (forall d.Data d => d -> u) ->WordPtr -> [u]Source # gmapQi ::Int -> (forall d.Data d => d -> u) ->WordPtr -> uSource # gmapM ::Monad m => (forall d.Data d => d -> m d) ->WordPtr -> mWordPtr Source # gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->WordPtr -> mWordPtr Source # gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->WordPtr -> mWordPtr Source #
Num WordPtrSource #
Instance details Defined inForeign.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 #
Ord WordPtrSource #
Instance details Defined inForeign.Ptr Methods compare ::WordPtr ->WordPtr ->Ordering # (<) ::WordPtr ->WordPtr ->Bool # (<=) ::WordPtr ->WordPtr ->Bool # (>) ::WordPtr ->WordPtr ->Bool # (>=) ::WordPtr ->WordPtr ->Bool # max ::WordPtr ->WordPtr ->WordPtr # min ::WordPtr ->WordPtr ->WordPtr #
Read WordPtrSource #
Instance details Defined inForeign.Ptr Methods readsPrec ::Int ->ReadS WordPtr Source # readList ::ReadS [WordPtr]Source # readPrec ::ReadPrec WordPtr Source # readListPrec ::ReadPrec [WordPtr]Source #
Real WordPtrSource #
Instance details Defined inForeign.Ptr Methods toRational ::WordPtr ->Rational Source #
Show WordPtrSource #
Instance details Defined inForeign.Ptr Methods showsPrec ::Int ->WordPtr ->ShowS Source # show ::WordPtr ->String Source # showList :: [WordPtr] ->ShowS Source #
FiniteBits WordPtrSource #
Instance details Defined inForeign.Ptr Methods finiteBitSize ::WordPtr ->Int Source # countLeadingZeros ::WordPtr ->Int Source # countTrailingZeros ::WordPtr ->Int Source #
Bits WordPtrSource #
Instance details Defined inForeign.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 #
Storable WordPtrSource #
Instance details Defined inForeign.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 #

ptrToWordPtr ::Ptr a ->WordPtr Source #

casts aPtr to aWordPtr

wordPtrToPtr ::WordPtr ->Ptr aSource #

casts aWordPtr to aPtr

Movatterモバイル変換

Data pointers

Function pointers

Integral types with lossless conversion to and from pointers