Foreign.Ptr.Diff

Documentation

newtype Diff a b

So long as minusPtr returns an Int, we're stuck with size of Int = size of ptrdiff_t

Constructors

Diff

Fields

• getDiff :: Int

Instances

Category Diff

Defined in Foreign.Ptr.Diff

Methods

id :: Diff a a

(.) :: Diff b c -> Diff a b -> Diff a c

Eq (Diff a b)

Defined in Foreign.Ptr.Diff

Methods

(==) :: Diff a b -> Diff a b -> Bool

(/=) :: Diff a b -> Diff a b -> Bool

(Data a, Data b) => Data (Diff a b)

Defined in Foreign.Ptr.Diff

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Diff a b -> c (Diff a b)

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Diff a b)

toConstr :: Diff a b -> Constr

dataTypeOf :: Diff a b -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Diff a b))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Diff a b))

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Diff a b -> Diff a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff a b -> r

gmapQ :: (forall d. Data d => d -> u) -> Diff a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Diff a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Diff a b -> m (Diff a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Diff a b -> m (Diff a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Diff a b -> m (Diff a b)

Ord (Diff a b)

Defined in Foreign.Ptr.Diff

Methods

compare :: Diff a b -> Diff a b -> Ordering

(<) :: Diff a b -> Diff a b -> Bool

(<=) :: Diff a b -> Diff a b -> Bool

(>) :: Diff a b -> Diff a b -> Bool

(>=) :: Diff a b -> Diff a b -> Bool

max :: Diff a b -> Diff a b -> Diff a b

min :: Diff a b -> Diff a b -> Diff a b

Read (Diff a b)

Defined in Foreign.Ptr.Diff

Methods

readsPrec :: Int -> ReadS (Diff a b)

readList :: ReadS [Diff a b]

readPrec :: ReadPrec (Diff a b)

readListPrec :: ReadPrec [Diff a b]

Show (Diff a b)

Defined in Foreign.Ptr.Diff

Methods

showsPrec :: Int -> Diff a b -> ShowS

show :: Diff a b -> String

showList :: [Diff a b] -> ShowS

Generic (Diff a b)

Defined in Foreign.Ptr.Diff

Associated Types

type Rep (Diff a b) :: Type -> Type

Methods

from :: Diff a b -> Rep (Diff a b) x

to :: Rep (Diff a b) x -> Diff a b

type Rep (Diff a b)

Defined in Foreign.Ptr.Diff

type Rep (Diff a b) = D1 (MetaData "Diff" "Foreign.Ptr.Diff" "ptrdiff-0-inplace" True) (C1 (MetaCons "Diff" PrefixI True) (S1 (MetaSel (Just "getDiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

inv :: Diff a b -> Diff b a

Invert a pointer Diff, e.g. convert a pointer to a field member to one that computes the location of the parent, or one that computes the offset of the next item into one that computes the offset of the previous element.

next :: forall a. Storable a => Diff a a

Calculate the position of the next elment of a given type when they are packed in densely.

prev :: Storable a => Diff a a

Calculate the position of the previous element of a given type when they are packed in densely.

(.*) :: Int -> Diff a a -> Diff a a infixr 6

Diff is a groupoid, so Diff a a is a group, and as such it forms a module over the integers

advance :: Storable a => Int -> Diff a a

Advance n (possibly negative) items in a dense packing.

class DiffTorsor t where

Methods

act :: Diff a b -> t a -> t b

diff :: t b -> t a -> Diff a b

Instances

DiffTorsor Ptr

Defined in Foreign.Ptr.Diff

Methods

act :: Diff a b -> Ptr a -> Ptr b

diff :: Ptr b -> Ptr a -> Diff a b

DiffTorsor FunPtr

Defined in Foreign.Ptr.Diff

Methods

act :: Diff a b -> FunPtr a -> FunPtr b

diff :: FunPtr b -> FunPtr a -> Diff a b

DiffTorsor ForeignPtr

due to finalizers this doesn't _quite_ satisfy ForeignPtr a * Diff a b - ForeignPtr a * ForeignPtr b

Defined in Foreign.Ptr.Diff

Methods

act :: Diff a b -> ForeignPtr a -> ForeignPtr b

diff :: ForeignPtr b -> ForeignPtr a -> Diff a b

peekDiffOff :: (MonadIO m, Storable b) => Ptr a -> Diff a b -> m b

peek using a Diff between pointers to calculate the offset.

pokeDiffOff :: (MonadIO m, Storable b) => Ptr a -> Diff a b -> b -> m ()

poke using a Diff between pointers to calculate the offset.