Foundation.Class.Storable

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

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 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 (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 (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 ()

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 -> Size Word8

alignment :: proxy a -> Size Word8

Instances

StorableFixed Char

Methods

size :: proxy Char -> Size Word8

alignment :: proxy Char -> Size Word8

StorableFixed Double

Methods

size :: proxy Double -> Size Word8

alignment :: proxy Double -> Size Word8

StorableFixed Float

Methods

size :: proxy Float -> Size Word8

alignment :: proxy Float -> Size Word8

StorableFixed Int8

Methods

size :: proxy Int8 -> Size Word8

alignment :: proxy Int8 -> Size Word8

StorableFixed Int16

Methods

size :: proxy Int16 -> Size Word8

alignment :: proxy Int16 -> Size Word8

StorableFixed Int32

Methods

size :: proxy Int32 -> Size Word8

alignment :: proxy Int32 -> Size Word8

StorableFixed Int64

Methods

size :: proxy Int64 -> Size Word8

alignment :: proxy Int64 -> Size Word8

StorableFixed Word8

Methods

size :: proxy Word8 -> Size Word8

alignment :: proxy Word8 -> Size Word8

StorableFixed Word16

Methods

size :: proxy Word16 -> Size Word8

alignment :: proxy Word16 -> Size Word8

StorableFixed Word32

Methods

size :: proxy Word32 -> Size Word8

alignment :: proxy Word32 -> Size Word8

StorableFixed Word64

Methods

size :: proxy Word64 -> Size Word8

alignment :: proxy Word64 -> Size Word8

StorableFixed CChar

Methods

size :: proxy CChar -> Size Word8

alignment :: proxy CChar -> Size Word8

StorableFixed CUChar

Methods

size :: proxy CUChar -> Size Word8

alignment :: proxy CUChar -> Size Word8

StorableFixed IPv4

Methods

size :: proxy IPv4 -> Size Word8

alignment :: proxy IPv4 -> Size Word8

StorableFixed IPv6

Methods

size :: proxy IPv6 -> Size Word8

alignment :: proxy IPv6 -> Size Word8

StorableFixed UUID

Methods

size :: proxy UUID -> Size Word8

alignment :: proxy UUID -> Size Word8

StorableFixed (Ptr a)

Methods

size :: proxy (Ptr a) -> Size Word8

alignment :: proxy (Ptr a) -> Size Word8

StorableFixed (BE Word16)

Methods

size :: proxy (BE Word16) -> Size Word8

alignment :: proxy (BE Word16) -> Size Word8

StorableFixed (BE Word32)

Methods

size :: proxy (BE Word32) -> Size Word8

alignment :: proxy (BE Word32) -> Size Word8

StorableFixed (BE Word64)

Methods

size :: proxy (BE Word64) -> Size Word8

alignment :: proxy (BE Word64) -> Size Word8

StorableFixed (LE Word16)

Methods

size :: proxy (LE Word16) -> Size Word8

alignment :: proxy (LE Word16) -> Size Word8

StorableFixed (LE Word32)

Methods

size :: proxy (LE Word32) -> Size Word8

alignment :: proxy (LE Word32) -> Size Word8

StorableFixed (LE Word64)

Methods

size :: proxy (LE Word64) -> Size Word8

alignment :: proxy (LE Word64) -> Size 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) -> Size Word8

alignment :: proxy (Ptr a) -> Size 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 -> Size 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)) => Size (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 ()