License	BSD-style
Maintainer	Haskell Foundation
Stability	experimental
Portability	portable
Safe Haskell	None
Language	Haskell2010

Foundation.Class.Storable

Contents

Ptr
offset based helper
Collection

Description

https://github.com/haskell-foundation/issues/111

Synopsis

Documentation

class Storable a where #

Storable type of self determined size.

Minimal complete definition

peek, poke

Methods

peek :: Ptr a -> IO a #

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

Instances

Storable Char #
Methods peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
Storable Double #
Methods peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Storable Float #
Methods peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
Storable Int8 #
Methods peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Storable Int16 #
Methods peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Storable Int32 #
Methods peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Storable Int64 #
Methods peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Storable Word8 #
Methods peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Storable Word16 #
Methods peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Storable Word32 #
Methods peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Storable Word64 #
Methods peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Storable CChar #
Methods peek :: Ptr CChar -> IO CChar # poke :: Ptr CChar -> CChar -> IO () #
Storable CUChar #
Methods peek :: Ptr CUChar -> IO CUChar # poke :: Ptr CUChar -> CUChar -> IO () #
Storable Word256 #
Methods peek :: Ptr Word256 -> IO Word256 # poke :: Ptr Word256 -> Word256 -> IO () #
Storable Word128 #
Methods peek :: Ptr Word128 -> IO Word128 # poke :: Ptr Word128 -> Word128 -> IO () #
Storable IPv4 #
Methods peek :: Ptr IPv4 -> IO IPv4 # poke :: Ptr IPv4 -> IPv4 -> IO () #
Storable IPv6 #
Methods peek :: Ptr IPv6 -> IO IPv6 # poke :: Ptr IPv6 -> IPv6 -> IO () #
Storable UUID #
Methods peek :: Ptr UUID -> IO UUID # poke :: Ptr UUID -> UUID -> IO () #
Storable (Ptr a) #
Methods peek :: Ptr (Ptr a) -> IO (Ptr a) # poke :: Ptr (Ptr a) -> Ptr a -> IO () #
Storable (LE Word16) #
Methods peek :: Ptr (LE Word16) -> IO (LE Word16) # poke :: Ptr (LE Word16) -> LE Word16 -> IO () #
Storable (LE Word32) #
Methods peek :: Ptr (LE Word32) -> IO (LE Word32) # poke :: Ptr (LE Word32) -> LE Word32 -> IO () #
Storable (LE Word64) #
Methods peek :: Ptr (LE Word64) -> IO (LE Word64) # poke :: Ptr (LE Word64) -> LE Word64 -> IO () #
Storable (LE Word256) #
Methods peek :: Ptr (LE Word256) -> IO (LE Word256) # poke :: Ptr (LE Word256) -> LE Word256 -> IO () #
Storable (LE Word128) #
Methods peek :: Ptr (LE Word128) -> IO (LE Word128) # poke :: Ptr (LE Word128) -> LE Word128 -> IO () #
Storable (BE Word16) #
Methods peek :: Ptr (BE Word16) -> IO (BE Word16) # poke :: Ptr (BE Word16) -> BE Word16 -> IO () #
Storable (BE Word32) #
Methods peek :: Ptr (BE Word32) -> IO (BE Word32) # poke :: Ptr (BE Word32) -> BE Word32 -> IO () #
Storable (BE Word64) #
Methods peek :: Ptr (BE Word64) -> IO (BE Word64) # poke :: Ptr (BE Word64) -> BE Word64 -> IO () #
Storable (BE Word256) #
Methods peek :: Ptr (BE Word256) -> IO (BE Word256) # poke :: Ptr (BE Word256) -> BE Word256 -> IO () #
Storable (BE Word128) #
Methods peek :: Ptr (BE Word128) -> IO (BE Word128) # poke :: Ptr (BE Word128) -> BE Word128 -> IO () #

class Storable a => StorableFixed a where #

Extending the Storable type class to the types that can be sequenced in a structure.

Minimal complete definition

size, alignment

Methods

size :: proxy a -> CountOf Word8 #

alignment :: proxy a -> CountOf Word8 #

Instances

StorableFixed Char #
Methods size :: proxy Char -> CountOf Word8 # alignment :: proxy Char -> CountOf Word8 #
StorableFixed Double #
Methods size :: proxy Double -> CountOf Word8 # alignment :: proxy Double -> CountOf Word8 #
StorableFixed Float #
Methods size :: proxy Float -> CountOf Word8 # alignment :: proxy Float -> CountOf Word8 #
StorableFixed Int8 #
Methods size :: proxy Int8 -> CountOf Word8 # alignment :: proxy Int8 -> CountOf Word8 #
StorableFixed Int16 #
Methods size :: proxy Int16 -> CountOf Word8 # alignment :: proxy Int16 -> CountOf Word8 #
StorableFixed Int32 #
Methods size :: proxy Int32 -> CountOf Word8 # alignment :: proxy Int32 -> CountOf Word8 #
StorableFixed Int64 #
Methods size :: proxy Int64 -> CountOf Word8 # alignment :: proxy Int64 -> CountOf Word8 #
StorableFixed Word8 #
Methods size :: proxy Word8 -> CountOf Word8 # alignment :: proxy Word8 -> CountOf Word8 #
StorableFixed Word16 #
Methods size :: proxy Word16 -> CountOf Word8 # alignment :: proxy Word16 -> CountOf Word8 #
StorableFixed Word32 #
Methods size :: proxy Word32 -> CountOf Word8 # alignment :: proxy Word32 -> CountOf Word8 #
StorableFixed Word64 #
Methods size :: proxy Word64 -> CountOf Word8 # alignment :: proxy Word64 -> CountOf Word8 #
StorableFixed CChar #
Methods size :: proxy CChar -> CountOf Word8 # alignment :: proxy CChar -> CountOf Word8 #
StorableFixed CUChar #
Methods size :: proxy CUChar -> CountOf Word8 # alignment :: proxy CUChar -> CountOf Word8 #
StorableFixed Word256 #
Methods size :: proxy Word256 -> CountOf Word8 # alignment :: proxy Word256 -> CountOf Word8 #
StorableFixed Word128 #
Methods size :: proxy Word128 -> CountOf Word8 # alignment :: proxy Word128 -> CountOf Word8 #
StorableFixed IPv4 #
Methods size :: proxy IPv4 -> CountOf Word8 # alignment :: proxy IPv4 -> CountOf Word8 #
StorableFixed IPv6 #
Methods size :: proxy IPv6 -> CountOf Word8 # alignment :: proxy IPv6 -> CountOf Word8 #
StorableFixed UUID #
Methods size :: proxy UUID -> CountOf Word8 # alignment :: proxy UUID -> CountOf Word8 #
StorableFixed (Ptr a) #
Methods size :: proxy (Ptr a) -> CountOf Word8 # alignment :: proxy (Ptr a) -> CountOf Word8 #
StorableFixed (LE Word16) #
Methods size :: proxy (LE Word16) -> CountOf Word8 # alignment :: proxy (LE Word16) -> CountOf Word8 #
StorableFixed (LE Word32) #
Methods size :: proxy (LE Word32) -> CountOf Word8 # alignment :: proxy (LE Word32) -> CountOf Word8 #
StorableFixed (LE Word64) #
Methods size :: proxy (LE Word64) -> CountOf Word8 # alignment :: proxy (LE Word64) -> CountOf Word8 #
StorableFixed (LE Word256) #
Methods size :: proxy (LE Word256) -> CountOf Word8 # alignment :: proxy (LE Word256) -> CountOf Word8 #
StorableFixed (LE Word128) #
Methods size :: proxy (LE Word128) -> CountOf Word8 # alignment :: proxy (LE Word128) -> CountOf Word8 #
StorableFixed (BE Word16) #
Methods size :: proxy (BE Word16) -> CountOf Word8 # alignment :: proxy (BE Word16) -> CountOf Word8 #
StorableFixed (BE Word32) #
Methods size :: proxy (BE Word32) -> CountOf Word8 # alignment :: proxy (BE Word32) -> CountOf Word8 #
StorableFixed (BE Word64) #
Methods size :: proxy (BE Word64) -> CountOf Word8 # alignment :: proxy (BE Word64) -> CountOf Word8 #
StorableFixed (BE Word256) #
Methods size :: proxy (BE Word256) -> CountOf Word8 # alignment :: proxy (BE Word256) -> CountOf Word8 #
StorableFixed (BE Word128) #
Methods size :: proxy (BE Word128) -> CountOf Word8 # alignment :: proxy (BE Word128) -> CountOf Word8 #

Ptr

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

Eq (Ptr a)
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Data a => Data (Ptr a)
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) #
Functor (URec (Ptr ()))
Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (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)
Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
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) #
Generic1 (URec (Ptr ()))
Associated Types type Rep1 (URec (Ptr ()) :: * -> ) :: -> * # Methods from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a # to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a #
Storable (Ptr a)
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 () #
NormalForm (Ptr a)
Methods toNormalForm :: Ptr a -> () #
StorableFixed (Ptr a) #
Methods size :: proxy (Ptr a) -> CountOf Word8 # alignment :: proxy (Ptr a) -> CountOf Word8 #
Storable (Ptr a) #
Methods peek :: Ptr (Ptr a) -> IO (Ptr a) # poke :: Ptr (Ptr a) -> Ptr a -> IO () #
Eq (URec (Ptr ()) p)
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
Ord (URec (Ptr ()) p)
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)
Associated Types type Rep (URec (Ptr ()) p) :: * -> * # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
type Rep1 (URec (Ptr ()))
type Rep1 (URec (Ptr ())) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))
data URec (Ptr ())	Used for marking occurrences of `Addr#`
data URec (Ptr ()) = UAddr { uAddr# :: Addr# }
type Rep (URec (Ptr ()) p)
type Rep (URec (Ptr ()) p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))

plusPtr :: StorableFixed a => Ptr a -> CountOf a -> Ptr a #

castPtr :: Ptr a -> Ptr b #

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

offset based helper

peekOff :: StorableFixed a => Ptr a -> Offset a -> IO a #

like peek but at a given offset.

pokeOff :: StorableFixed a => Ptr a -> Offset a -> a -> IO () #

like poke but at a given offset.

Collection

peekArray :: (Buildable col, StorableFixed (Element col)) => CountOf (Element col) -> Ptr (Element col) -> IO col #

peekArrayEndedBy :: (Buildable col, StorableFixed (Element col), Eq (Element col), Show (Element col)) => Element col -> Ptr (Element col) -> IO col #

pokeArray :: (Sequential col, StorableFixed (Element col)) => Ptr (Element col) -> col -> IO () #

pokeArrayEndedBy :: (Sequential col, StorableFixed (Element col)) => Element col -> Ptr (Element col) -> col -> IO () #