foundation-0.0.15: Alternative prelude with batteries and no dependencies

LicenseBSD-style
MaintainerHaskell Foundation
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

Foundation.Class.Storable

Contents

Description

Synopsis

Documentation

class Storable a where Source #

Storable type of self determined size.

Minimal complete definition

peek, poke

Methods

peek :: Ptr a -> IO a Source #

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

Instances

Storable Char Source # 

Methods

peek :: Ptr Char -> IO Char Source #

poke :: Ptr Char -> Char -> IO () Source #

Storable Double Source # 
Storable Float Source # 

Methods

peek :: Ptr Float -> IO Float Source #

poke :: Ptr Float -> Float -> IO () Source #

Storable Int8 Source # 

Methods

peek :: Ptr Int8 -> IO Int8 Source #

poke :: Ptr Int8 -> Int8 -> IO () Source #

Storable Int16 Source # 

Methods

peek :: Ptr Int16 -> IO Int16 Source #

poke :: Ptr Int16 -> Int16 -> IO () Source #

Storable Int32 Source # 

Methods

peek :: Ptr Int32 -> IO Int32 Source #

poke :: Ptr Int32 -> Int32 -> IO () Source #

Storable Int64 Source # 

Methods

peek :: Ptr Int64 -> IO Int64 Source #

poke :: Ptr Int64 -> Int64 -> IO () Source #

Storable Word8 Source # 

Methods

peek :: Ptr Word8 -> IO Word8 Source #

poke :: Ptr Word8 -> Word8 -> IO () Source #

Storable Word16 Source # 
Storable Word32 Source # 
Storable Word64 Source # 
Storable CChar Source # 

Methods

peek :: Ptr CChar -> IO CChar Source #

poke :: Ptr CChar -> CChar -> IO () Source #

Storable CUChar Source # 
Storable Word256 Source # 
Storable Word128 Source # 
Storable IPv4 Source # 

Methods

peek :: Ptr IPv4 -> IO IPv4 Source #

poke :: Ptr IPv4 -> IPv4 -> IO () Source #

Storable IPv6 Source # 

Methods

peek :: Ptr IPv6 -> IO IPv6 Source #

poke :: Ptr IPv6 -> IPv6 -> IO () Source #

Storable UUID Source # 

Methods

peek :: Ptr UUID -> IO UUID Source #

poke :: Ptr UUID -> UUID -> IO () Source #

Storable (Ptr a) Source # 

Methods

peek :: Ptr (Ptr a) -> IO (Ptr a) Source #

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

Storable (LE Word16) Source # 

Methods

peek :: Ptr (LE Word16) -> IO (LE Word16) Source #

poke :: Ptr (LE Word16) -> LE Word16 -> IO () Source #

Storable (LE Word32) Source # 

Methods

peek :: Ptr (LE Word32) -> IO (LE Word32) Source #

poke :: Ptr (LE Word32) -> LE Word32 -> IO () Source #

Storable (LE Word64) Source # 

Methods

peek :: Ptr (LE Word64) -> IO (LE Word64) Source #

poke :: Ptr (LE Word64) -> LE Word64 -> IO () Source #

Storable (LE Word256) Source # 

Methods

peek :: Ptr (LE Word256) -> IO (LE Word256) Source #

poke :: Ptr (LE Word256) -> LE Word256 -> IO () Source #

Storable (LE Word128) Source # 

Methods

peek :: Ptr (LE Word128) -> IO (LE Word128) Source #

poke :: Ptr (LE Word128) -> LE Word128 -> IO () Source #

Storable (BE Word16) Source # 

Methods

peek :: Ptr (BE Word16) -> IO (BE Word16) Source #

poke :: Ptr (BE Word16) -> BE Word16 -> IO () Source #

Storable (BE Word32) Source # 

Methods

peek :: Ptr (BE Word32) -> IO (BE Word32) Source #

poke :: Ptr (BE Word32) -> BE Word32 -> IO () Source #

Storable (BE Word64) Source # 

Methods

peek :: Ptr (BE Word64) -> IO (BE Word64) Source #

poke :: Ptr (BE Word64) -> BE Word64 -> IO () Source #

Storable (BE Word256) Source # 

Methods

peek :: Ptr (BE Word256) -> IO (BE Word256) Source #

poke :: Ptr (BE Word256) -> BE Word256 -> IO () Source #

Storable (BE Word128) Source # 

Methods

peek :: Ptr (BE Word128) -> IO (BE Word128) Source #

poke :: Ptr (BE Word128) -> BE Word128 -> IO () Source #

class Storable a => StorableFixed a where Source #

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 Source #

alignment :: proxy a -> CountOf Word8 Source #

Instances

StorableFixed Char Source # 

Methods

size :: proxy Char -> CountOf Word8 Source #

alignment :: proxy Char -> CountOf Word8 Source #

StorableFixed Double Source # 
StorableFixed Float Source # 

Methods

size :: proxy Float -> CountOf Word8 Source #

alignment :: proxy Float -> CountOf Word8 Source #

StorableFixed Int8 Source # 

Methods

size :: proxy Int8 -> CountOf Word8 Source #

alignment :: proxy Int8 -> CountOf Word8 Source #

StorableFixed Int16 Source # 

Methods

size :: proxy Int16 -> CountOf Word8 Source #

alignment :: proxy Int16 -> CountOf Word8 Source #

StorableFixed Int32 Source # 

Methods

size :: proxy Int32 -> CountOf Word8 Source #

alignment :: proxy Int32 -> CountOf Word8 Source #

StorableFixed Int64 Source # 

Methods

size :: proxy Int64 -> CountOf Word8 Source #

alignment :: proxy Int64 -> CountOf Word8 Source #

StorableFixed Word8 Source # 

Methods

size :: proxy Word8 -> CountOf Word8 Source #

alignment :: proxy Word8 -> CountOf Word8 Source #

StorableFixed Word16 Source # 
StorableFixed Word32 Source # 
StorableFixed Word64 Source # 
StorableFixed CChar Source # 

Methods

size :: proxy CChar -> CountOf Word8 Source #

alignment :: proxy CChar -> CountOf Word8 Source #

StorableFixed CUChar Source # 
StorableFixed Word256 Source # 
StorableFixed Word128 Source # 
StorableFixed IPv4 Source # 

Methods

size :: proxy IPv4 -> CountOf Word8 Source #

alignment :: proxy IPv4 -> CountOf Word8 Source #

StorableFixed IPv6 Source # 

Methods

size :: proxy IPv6 -> CountOf Word8 Source #

alignment :: proxy IPv6 -> CountOf Word8 Source #

StorableFixed UUID Source # 

Methods

size :: proxy UUID -> CountOf Word8 Source #

alignment :: proxy UUID -> CountOf Word8 Source #

StorableFixed (Ptr a) Source # 

Methods

size :: proxy (Ptr a) -> CountOf Word8 Source #

alignment :: proxy (Ptr a) -> CountOf Word8 Source #

StorableFixed (LE Word16) Source # 

Methods

size :: proxy (LE Word16) -> CountOf Word8 Source #

alignment :: proxy (LE Word16) -> CountOf Word8 Source #

StorableFixed (LE Word32) Source # 

Methods

size :: proxy (LE Word32) -> CountOf Word8 Source #

alignment :: proxy (LE Word32) -> CountOf Word8 Source #

StorableFixed (LE Word64) Source # 

Methods

size :: proxy (LE Word64) -> CountOf Word8 Source #

alignment :: proxy (LE Word64) -> CountOf Word8 Source #

StorableFixed (LE Word256) Source # 

Methods

size :: proxy (LE Word256) -> CountOf Word8 Source #

alignment :: proxy (LE Word256) -> CountOf Word8 Source #

StorableFixed (LE Word128) Source # 

Methods

size :: proxy (LE Word128) -> CountOf Word8 Source #

alignment :: proxy (LE Word128) -> CountOf Word8 Source #

StorableFixed (BE Word16) Source # 

Methods

size :: proxy (BE Word16) -> CountOf Word8 Source #

alignment :: proxy (BE Word16) -> CountOf Word8 Source #

StorableFixed (BE Word32) Source # 

Methods

size :: proxy (BE Word32) -> CountOf Word8 Source #

alignment :: proxy (BE Word32) -> CountOf Word8 Source #

StorableFixed (BE Word64) Source # 

Methods

size :: proxy (BE Word64) -> CountOf Word8 Source #

alignment :: proxy (BE Word64) -> CountOf Word8 Source #

StorableFixed (BE Word256) Source # 

Methods

size :: proxy (BE Word256) -> CountOf Word8 Source #

alignment :: proxy (BE Word256) -> CountOf Word8 Source #

StorableFixed (BE Word128) Source # 

Methods

size :: proxy (BE Word128) -> CountOf Word8 Source #

alignment :: proxy (BE Word128) -> CountOf Word8 Source #

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) Source # 

Methods

size :: proxy (Ptr a) -> CountOf Word8 Source #

alignment :: proxy (Ptr a) -> CountOf Word8 Source #

Storable (Ptr a) Source # 

Methods

peek :: Ptr (Ptr a) -> IO (Ptr a) Source #

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

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 {}
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))

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 Source #

like peek but at a given offset.

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

like poke but at a given offset.

Collection

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

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

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

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