Copyright	(C) 2012-2016 Edward Kmett (C) 2017 Ryan Scott
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	experimental
Portability	non-portable
Safe Haskell	Safe
Language	Haskell98

Control.Lens.Internal.CTypes

Description

In Control.Lens.Wrapped, we need to muck around with the internals of the newtypes in Foreign.C.Types. Unfortunately, the exact types used varies wildly from platform to platform, so trying to manage the imports necessary to bring these types in scope can be unwieldy.

To make things easier, we use this module as a way to import everything carte blanche that might be used internally in Foreign.C.Types. For now, this consists of all the exports from the Data.Int and Data.Word modules, as well as the Ptr type.

Synopsis

Documentation

module Data.Int

data Ptr a :: * -> * #

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

IArray UArray (Ptr a)
Methods bounds :: Ix i => UArray i (Ptr a) -> (i, i) # numElements :: Ix i => UArray i (Ptr a) -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Ptr a)] -> UArray i (Ptr a) unsafeAt :: Ix i => UArray i (Ptr a) -> Int -> Ptr a unsafeReplace :: Ix i => UArray i (Ptr a) -> [(Int, Ptr a)] -> UArray i (Ptr a) unsafeAccum :: Ix i => (Ptr a -> e' -> Ptr a) -> UArray i (Ptr a) -> [(Int, e')] -> UArray i (Ptr a) unsafeAccumArray :: Ix i => (Ptr a -> e' -> Ptr a) -> Ptr a -> (i, i) -> [(Int, e')] -> UArray i (Ptr a)
Generic1 k (URec k (Ptr ()))
Associated Types type Rep1 (URec k (Ptr ())) (f :: URec k (Ptr ()) -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k (Ptr ())) f a # to1 :: Rep1 (URec k (Ptr ())) f a -> f a #
Eq (Ptr a)
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Data a => Data (Ptr a)	Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) # toConstr :: Ptr a -> Constr # dataTypeOf :: Ptr a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) #
Ord (Ptr a)
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)	Since: 2.1
Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Storable (Ptr a)	Since: 2.1
Methods sizeOf :: Ptr a -> Int # alignment :: Ptr a -> Int # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ptr a) # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () # peek :: Ptr (Ptr a) -> IO (Ptr a) # poke :: Ptr (Ptr a) -> Ptr a -> IO () #
Hashable (Ptr a)
Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Prim (Ptr a)
Methods sizeOf# :: Ptr a -> Int# # alignment# :: Ptr a -> Int# # indexByteArray# :: ByteArray# -> Int# -> Ptr a # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#) # writeByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Ptr a -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Ptr a # readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#) # writeOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Ptr a -> State# s -> State# s #
Storable a => HasSetter (Ptr a) a
Methods ($=) :: MonadIO m => Ptr a -> a -> m () #
Storable a => HasGetter (Ptr a) a
Methods get :: MonadIO m => Ptr a -> m a #
Storable a => HasUpdate (Ptr a) a a
Methods ($~) :: MonadIO m => Ptr a -> (a -> a) -> m () # ($~!) :: MonadIO m => Ptr a -> (a -> a) -> m () #
MArray (STUArray s) (Ptr a) (ST s)
Methods getBounds :: Ix i => STUArray s i (Ptr a) -> ST s (i, i) # getNumElements :: Ix i => STUArray s i (Ptr a) -> ST s Int newArray :: Ix i => (i, i) -> Ptr a -> ST s (STUArray s i (Ptr a)) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i (Ptr a)) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i (Ptr a)) unsafeRead :: Ix i => STUArray s i (Ptr a) -> Int -> ST s (Ptr a) unsafeWrite :: Ix i => STUArray s i (Ptr a) -> Int -> Ptr a -> ST s ()
Functor (URec * (Ptr ()))
Methods fmap :: (a -> b) -> URec * (Ptr ()) a -> URec * (Ptr ()) b # (<$) :: a -> URec * (Ptr ()) b -> URec * (Ptr ()) a #
Foldable (URec * (Ptr ()))
Methods fold :: Monoid m => URec * (Ptr ()) m -> m # foldMap :: Monoid m => (a -> m) -> URec * (Ptr ()) a -> m # foldr :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b # foldr' :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b # foldl :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b # foldl' :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b # foldr1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a # foldl1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a # toList :: URec * (Ptr ()) a -> [a] # null :: URec * (Ptr ()) a -> Bool # length :: URec * (Ptr ()) a -> Int # elem :: Eq a => a -> URec * (Ptr ()) a -> Bool # maximum :: Ord a => URec * (Ptr ()) a -> a # minimum :: Ord a => URec * (Ptr ()) a -> a # sum :: Num a => URec * (Ptr ()) a -> a # product :: Num a => URec * (Ptr ()) a -> a #
Traversable (URec * (Ptr ()))
Methods traverse :: Applicative f => (a -> f b) -> URec * (Ptr ()) a -> f (URec * (Ptr ()) b) # sequenceA :: Applicative f => URec * (Ptr ()) (f a) -> f (URec * (Ptr ()) a) # mapM :: Monad m => (a -> m b) -> URec * (Ptr ()) a -> m (URec * (Ptr ()) b) # sequence :: Monad m => URec * (Ptr ()) (m a) -> m (URec * (Ptr ()) a) #
Eq (URec k (Ptr ()) p)
Methods (==) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # (/=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool #
Ord (URec k (Ptr ()) p)
Methods compare :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Ordering # (<) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # (<=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # (>) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # (>=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # max :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> URec k (Ptr ()) p # min :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> URec k (Ptr ()) p #
Generic (URec k (Ptr ()) p)
Associated Types type Rep (URec k (Ptr ()) p) :: * -> * # Methods from :: URec k (Ptr ()) p -> Rep (URec k (Ptr ()) p) x # to :: Rep (URec k (Ptr ()) p) x -> URec k (Ptr ()) p #
data URec k (Ptr ())	Used for marking occurrences of `Addr#` Since: 4.9.0.0
data URec k (Ptr ()) = UAddr { uAddr# :: Addr# }
type Rep1 k (URec k (Ptr ()))
type Rep1 k (URec k (Ptr ())) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UAddr" PrefixI True) (S1 k (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr k)))
type Rep (URec k (Ptr ()) p)
type Rep (URec k (Ptr ()) p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UAddr" PrefixI True) (S1 * (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr *)))

module Data.Word