Copyright | (c) The FFI Task Force 2000-2002 |
---|---|

License | see libraries/base/LICENSE |

Maintainer | [email protected] |

Stability | internal |

Portability | non-portable (GHC Extensions) |

Safe Haskell | Unsafe |

Language | Haskell2010 |

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`

.

Generic1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0 |

Eq (Ptr a) | Since: base-2.1 |

Data a => Data (Ptr a) | Since: base-4.8.0.0 |

Defined in Data.Data ## Methodsgfoldl :: (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 a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source 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) | Since: base-2.1 |

Show (Ptr a) | Since: base-2.1 |

Storable (Ptr a) | Since: base-2.1 |

Defined in Foreign.Storable | |

Functor (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |

Foldable (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |

Defined in Data.Foldable ## Methodsfold :: Monoid m => URec (Ptr ()) m -> m Source foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source foldMap' :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source 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 -> a Source minimum :: Ord a => URec (Ptr ()) a -> a Source | |

Traversable (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |

Defined in Data.Traversable ## Methodstraverse :: 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) | Since: base-4.9.0.0 |

Ord (URec (Ptr ()) p) | Since: base-4.9.0.0 |

Defined in GHC.Generics ## Methodscompare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source | |

Generic (URec (Ptr ()) p) | Since: base-4.9.0.0 |

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

type Rep1 (URec (Ptr ()) :: k -> Type) | |

Defined in GHC.Generics | |

type Rep (URec (Ptr ()) p) | |

Defined in GHC.Generics |

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

Eq (FunPtr a) | |

Ord (FunPtr a) | |

Show (FunPtr a) | Since: base-2.1 |

Storable (FunPtr a) | Since: base-2.1 |

Defined in Foreign.Storable ## MethodssizeOf :: 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 |

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)

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

*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

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

© The University of Glasgow and others

Licensed under a BSD-style license (see top of the page).

https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/GHC-Ptr.html