Safe Haskell	None
Language	Haskell2010

Rebase.Data.Vector.Storable

Synopsis

(++) :: Storable a => Vector a -> Vector a -> Vector a
foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b
map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
(!) :: Storable a => Vector a -> Int -> a
(//) :: Storable a => Vector a -> [(Int, a)] -> Vector a
accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
(!?) :: Storable a => Vector a -> Int -> Maybe a
freeze :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
unsafeFreeze :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
thaw :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
unsafeThaw :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
concat :: Storable a => [Vector a] -> Vector a
foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a
mapMaybe :: (Storable a, Storable b) => (a -> Maybe b) -> Vector a -> Vector b
maximumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
minimumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
class Storable a
length :: Storable a => Vector a -> Int
head :: Storable a => Vector a -> a
group :: (Storable a, Eq a) => Vector a -> [Vector a]
groupBy :: Storable a => (a -> a -> Bool) -> Vector a -> [Vector a]
foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a
foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a
mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b)
forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b)
mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m ()
forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m ()
foldMap :: (Monoid m, Storable a) => (a -> m) -> Vector a -> m
filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
fromList :: Storable a => [a] -> Vector a
fromListN :: Storable a => Int -> [a] -> Vector a
toList :: Storable a => Vector a -> [a]
empty :: Storable a => Vector a
uncons :: Storable a => Vector a -> Maybe (a, Vector a)
unsnoc :: Storable a => Vector a -> Maybe (Vector a, a)
tail :: Storable a => Vector a -> Vector a
last :: Storable a => Vector a -> a
init :: Storable a => Vector a -> Vector a
null :: Storable a => Vector a -> Bool
foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a
sum :: (Storable a, Num a) => Vector a -> a
product :: (Storable a, Num a) => Vector a -> a
scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
foldr' :: Storable a => (a -> b -> b) -> b -> Vector a -> b
foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a
scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
maximum :: (Storable a, Ord a) => Vector a -> a
minimum :: (Storable a, Ord a) => Vector a -> a
replicate :: Storable a => Int -> a -> Vector a
takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
take :: Storable a => Int -> Vector a -> Vector a
drop :: Storable a => Int -> Vector a -> Vector a
splitAt :: Storable a => Int -> Vector a -> (Vector a, Vector a)
span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
reverse :: Storable a => Vector a -> Vector a
and :: Vector Bool -> Bool
or :: Vector Bool -> Bool
any :: Storable a => (a -> Bool) -> Vector a -> Bool
all :: Storable a => (a -> Bool) -> Vector a -> Bool
elem :: (Storable a, Eq a) => a -> Vector a -> Bool
notElem :: (Storable a, Eq a) => a -> Vector a -> Bool
concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b
zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
unsafeIndex :: Storable a => Vector a -> Int -> a
foldMap' :: (Monoid m, Storable a) => (a -> m) -> Vector a -> m
find :: Storable a => (a -> Bool) -> Vector a -> Maybe a
elemIndex :: (Storable a, Eq a) => a -> Vector a -> Maybe Int
elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int
findIndex :: Storable a => (a -> Bool) -> Vector a -> Maybe Int
findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int
partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
singleton :: Storable a => a -> Vector a
filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a)
zipWithM :: (Monad m, Storable a, Storable b, Storable c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
zipWithM_ :: (Monad m, Storable a, Storable b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
foldM_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m ()
replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a)
cons :: Storable a => a -> Vector a -> Vector a
foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a
copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
snoc :: Storable a => Vector a -> a -> Vector a
create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
unsafeHead :: Storable a => Vector a -> a
unsafeTail :: Storable a => Vector a -> Vector a
unsafeInit :: Storable a => Vector a -> Vector a
unsafeLast :: Storable a => Vector a -> a
unsafeTake :: Storable a => Int -> Vector a -> Vector a
unsafeDrop :: Storable a => Int -> Vector a -> Vector a
iterateN :: Storable a => Int -> (a -> a) -> a -> Vector a
findIndexR :: Storable a => (a -> Bool) -> Vector a -> Maybe Int
force :: Storable a => Vector a -> Vector a
ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b
imapM :: (Monad m, Storable a, Storable b) => (Int -> a -> m b) -> Vector a -> m (Vector b)
iforM :: (Monad m, Storable a, Storable b) => Vector a -> (Int -> a -> m b) -> m (Vector b)
imapM_ :: (Monad m, Storable a) => (Int -> a -> m b) -> Vector a -> m ()
iforM_ :: (Monad m, Storable a) => Vector a -> (Int -> a -> m b) -> m ()
modify :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
indexM :: (Storable a, Monad m) => Vector a -> Int -> m a
generate :: Storable a => Int -> (Int -> a) -> Vector a
generateM :: (Monad m, Storable a) => Int -> (Int -> m a) -> m (Vector a)
slice :: Storable a => Int -> Int -> Vector a -> Vector a
eqBy :: (Storable a, Storable b) => (a -> b -> Bool) -> Vector a -> Vector b -> Bool
cmpBy :: (Storable a, Storable b) => (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
mapMaybeM :: (Monad m, Storable a, Storable b) => (a -> m (Maybe b)) -> Vector a -> m (Vector b)
uniq :: (Storable a, Eq a) => Vector a -> Vector a
fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
unfoldrM :: (Monad m, Storable a) => (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrNM :: (Monad m, Storable a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrExactN :: Storable a => Int -> (b -> (a, b)) -> b -> Vector a
unfoldrExactNM :: (Monad m, Storable a) => Int -> (b -> m (a, b)) -> b -> m (Vector a)
iterateNM :: (Monad m, Storable a) => Int -> (a -> m a) -> a -> m (Vector a)
prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a
data Vector a
convert :: (Vector v a, Vector w a) => v a -> w a
accumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
backpermute :: Storable a => Vector a -> Vector Int -> Vector a
breakR :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
constructN :: Storable a => Int -> (Vector a -> a) -> Vector a
constructrN :: Storable a => Int -> (Vector a -> a) -> Vector a
createT :: (Traversable f, Storable a) => (forall s. ST s (f (MVector s a))) -> f (Vector a)
enumFromN :: (Storable a, Num a) => a -> Int -> Vector a
fold1M'_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m ()
fold1M_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m ()
foldM'_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m ()
headM :: (Storable a, Monad m) => Vector a -> m a
ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a
ifoldM :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
ifoldM' :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
ifoldM'_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
ifoldM_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
imapMaybe :: (Storable a, Storable b) => (Int -> a -> Maybe b) -> Vector a -> Vector b
imapMaybeM :: (Monad m, Storable a, Storable b) => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b)
iscanl :: (Storable a, Storable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
iscanl' :: (Storable a, Storable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
iscanr :: (Storable a, Storable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
iscanr' :: (Storable a, Storable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
izipWith :: (Storable a, Storable b, Storable c) => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
izipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
izipWithM :: (Monad m, Storable a, Storable b, Storable c) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
izipWithM_ :: (Monad m, Storable a, Storable b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
lastM :: (Storable a, Monad m) => Vector a -> m a
maxIndex :: (Storable a, Ord a) => Vector a -> Int
maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
maximumOn :: (Ord b, Storable a) => (a -> b) -> Vector a -> a
minIndex :: (Storable a, Ord a) => Vector a -> Int
minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
minimumOn :: (Ord b, Storable a) => (a -> b) -> Vector a -> a
partitionWith :: (Storable a, Storable b, Storable c) => (a -> Either b c) -> Vector a -> (Vector b, Vector c)
postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
spanR :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
unsafeAccumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a
unsafeCopy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
unsafeHeadM :: (Storable a, Monad m) => Vector a -> m a
unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a
unsafeLastM :: (Storable a, Monad m) => Vector a -> m a
unsafeSlice :: Storable a => Int -> Int -> Vector a -> Vector a
unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a
unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
unstablePartition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
update_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
data MVector s a = MVector !Int !(ForeignPtr a)
unsafeCast :: (Storable a, Storable b) => Vector a -> Vector b
unsafeCoerceVector :: Coercible a b => Vector a -> Vector b
unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Int -> Int -> Vector a
isSameVector :: Storable a => Vector a -> Vector a -> Bool
unsafeFromForeignPtr0 :: ForeignPtr a -> Int -> Vector a
unsafeToForeignPtr :: Vector a -> (ForeignPtr a, Int, Int)
unsafeToForeignPtr0 :: Vector a -> (ForeignPtr a, Int)
unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b

Documentation

(++) :: Storable a => Vector a -> Vector a -> Vector a #

foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b #

map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b #

(!) :: Storable a => Vector a -> Int -> a #

(//) :: Storable a => Vector a -> [(Int, a)] -> Vector a #

accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a #

unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a #

(!?) :: Storable a => Vector a -> Int -> Maybe a #

freeze :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a) #

unsafeFreeze :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a) #

thaw :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a) #

unsafeThaw :: (Storable a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a) #

concat :: Storable a => [Vector a] -> Vector a #

foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a #

mapMaybe :: (Storable a, Storable b) => (a -> Maybe b) -> Vector a -> Vector b #

maximumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a #

minimumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a #

class Storable a #

The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type Ptr a, for some a which is an instance of class Storable. The type argument to Ptr helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class Storable facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size Int types (Int8, Int16, Int32, Int64), the fixed size Word types (Word8, Word16, Word32, Word64), StablePtr, all types from Foreign.C.Types, as well as Ptr.

Minimal complete definition

sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff)

Instances

Instances details

Storable CBool
Instance details Defined in Foreign.C.Types Methods sizeOf :: CBool -> Int # alignment :: CBool -> Int # peekElemOff :: Ptr CBool -> Int -> IO CBool # pokeElemOff :: Ptr CBool -> Int -> CBool -> IO () # peekByteOff :: Ptr b -> Int -> IO CBool # pokeByteOff :: Ptr b -> Int -> CBool -> IO () # peek :: Ptr CBool -> IO CBool # poke :: Ptr CBool -> CBool -> IO () #
Storable CChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CChar -> Int # alignment :: CChar -> Int # peekElemOff :: Ptr CChar -> Int -> IO CChar # pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CChar # pokeByteOff :: Ptr b -> Int -> CChar -> IO () # peek :: Ptr CChar -> IO CChar # poke :: Ptr CChar -> CChar -> IO () #
Storable CClock
Instance details Defined in Foreign.C.Types Methods sizeOf :: CClock -> Int # alignment :: CClock -> Int # peekElemOff :: Ptr CClock -> Int -> IO CClock # pokeElemOff :: Ptr CClock -> Int -> CClock -> IO () # peekByteOff :: Ptr b -> Int -> IO CClock # pokeByteOff :: Ptr b -> Int -> CClock -> IO () # peek :: Ptr CClock -> IO CClock # poke :: Ptr CClock -> CClock -> IO () #
Storable CDouble
Instance details Defined in Foreign.C.Types Methods sizeOf :: CDouble -> Int # alignment :: CDouble -> Int # peekElemOff :: Ptr CDouble -> Int -> IO CDouble # pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO () # peekByteOff :: Ptr b -> Int -> IO CDouble # pokeByteOff :: Ptr b -> Int -> CDouble -> IO () # peek :: Ptr CDouble -> IO CDouble # poke :: Ptr CDouble -> CDouble -> IO () #
Storable CFloat
Instance details Defined in Foreign.C.Types Methods sizeOf :: CFloat -> Int # alignment :: CFloat -> Int # peekElemOff :: Ptr CFloat -> Int -> IO CFloat # pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO () # peekByteOff :: Ptr b -> Int -> IO CFloat # pokeByteOff :: Ptr b -> Int -> CFloat -> IO () # peek :: Ptr CFloat -> IO CFloat # poke :: Ptr CFloat -> CFloat -> IO () #
Storable CInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CInt -> Int # alignment :: CInt -> Int # peekElemOff :: Ptr CInt -> Int -> IO CInt # pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () # peekByteOff :: Ptr b -> Int -> IO CInt # pokeByteOff :: Ptr b -> Int -> CInt -> IO () # peek :: Ptr CInt -> IO CInt # poke :: Ptr CInt -> CInt -> IO () #
Storable CIntMax
Instance details Defined in Foreign.C.Types Methods sizeOf :: CIntMax -> Int # alignment :: CIntMax -> Int # peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax # pokeElemOff :: Ptr CIntMax -> Int -> CIntMax -> IO () # peekByteOff :: Ptr b -> Int -> IO CIntMax # pokeByteOff :: Ptr b -> Int -> CIntMax -> IO () # peek :: Ptr CIntMax -> IO CIntMax # poke :: Ptr CIntMax -> CIntMax -> IO () #
Storable CIntPtr
Instance details Defined in Foreign.C.Types Methods sizeOf :: CIntPtr -> Int # alignment :: CIntPtr -> Int # peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr # pokeElemOff :: Ptr CIntPtr -> Int -> CIntPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO CIntPtr # pokeByteOff :: Ptr b -> Int -> CIntPtr -> IO () # peek :: Ptr CIntPtr -> IO CIntPtr # poke :: Ptr CIntPtr -> CIntPtr -> IO () #
Storable CLLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLLong -> Int # alignment :: CLLong -> Int # peekElemOff :: Ptr CLLong -> Int -> IO CLLong # pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CLLong # pokeByteOff :: Ptr b -> Int -> CLLong -> IO () # peek :: Ptr CLLong -> IO CLLong # poke :: Ptr CLLong -> CLLong -> IO () #
Storable CLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLong -> Int # alignment :: CLong -> Int # peekElemOff :: Ptr CLong -> Int -> IO CLong # pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CLong # pokeByteOff :: Ptr b -> Int -> CLong -> IO () # peek :: Ptr CLong -> IO CLong # poke :: Ptr CLong -> CLong -> IO () #
Storable CPtrdiff
Instance details Defined in Foreign.C.Types Methods sizeOf :: CPtrdiff -> Int # alignment :: CPtrdiff -> Int # peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff # pokeElemOff :: Ptr CPtrdiff -> Int -> CPtrdiff -> IO () # peekByteOff :: Ptr b -> Int -> IO CPtrdiff # pokeByteOff :: Ptr b -> Int -> CPtrdiff -> IO () # peek :: Ptr CPtrdiff -> IO CPtrdiff # poke :: Ptr CPtrdiff -> CPtrdiff -> IO () #
Storable CSChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSChar -> Int # alignment :: CSChar -> Int # peekElemOff :: Ptr CSChar -> Int -> IO CSChar # pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CSChar # pokeByteOff :: Ptr b -> Int -> CSChar -> IO () # peek :: Ptr CSChar -> IO CSChar # poke :: Ptr CSChar -> CSChar -> IO () #
Storable CSUSeconds
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSUSeconds -> Int # alignment :: CSUSeconds -> Int # peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds # pokeElemOff :: Ptr CSUSeconds -> Int -> CSUSeconds -> IO () # peekByteOff :: Ptr b -> Int -> IO CSUSeconds # pokeByteOff :: Ptr b -> Int -> CSUSeconds -> IO () # peek :: Ptr CSUSeconds -> IO CSUSeconds # poke :: Ptr CSUSeconds -> CSUSeconds -> IO () #
Storable CShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CShort -> Int # alignment :: CShort -> Int # peekElemOff :: Ptr CShort -> Int -> IO CShort # pokeElemOff :: Ptr CShort -> Int -> CShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CShort # pokeByteOff :: Ptr b -> Int -> CShort -> IO () # peek :: Ptr CShort -> IO CShort # poke :: Ptr CShort -> CShort -> IO () #
Storable CSigAtomic
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSigAtomic -> Int # alignment :: CSigAtomic -> Int # peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic # pokeElemOff :: Ptr CSigAtomic -> Int -> CSigAtomic -> IO () # peekByteOff :: Ptr b -> Int -> IO CSigAtomic # pokeByteOff :: Ptr b -> Int -> CSigAtomic -> IO () # peek :: Ptr CSigAtomic -> IO CSigAtomic # poke :: Ptr CSigAtomic -> CSigAtomic -> IO () #
Storable CSize
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSize -> Int # alignment :: CSize -> Int # peekElemOff :: Ptr CSize -> Int -> IO CSize # pokeElemOff :: Ptr CSize -> Int -> CSize -> IO () # peekByteOff :: Ptr b -> Int -> IO CSize # pokeByteOff :: Ptr b -> Int -> CSize -> IO () # peek :: Ptr CSize -> IO CSize # poke :: Ptr CSize -> CSize -> IO () #
Storable CTime
Instance details Defined in Foreign.C.Types Methods sizeOf :: CTime -> Int # alignment :: CTime -> Int # peekElemOff :: Ptr CTime -> Int -> IO CTime # pokeElemOff :: Ptr CTime -> Int -> CTime -> IO () # peekByteOff :: Ptr b -> Int -> IO CTime # pokeByteOff :: Ptr b -> Int -> CTime -> IO () # peek :: Ptr CTime -> IO CTime # poke :: Ptr CTime -> CTime -> IO () #
Storable CUChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUChar -> Int # alignment :: CUChar -> Int # peekElemOff :: Ptr CUChar -> Int -> IO CUChar # pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CUChar # pokeByteOff :: Ptr b -> Int -> CUChar -> IO () # peek :: Ptr CUChar -> IO CUChar # poke :: Ptr CUChar -> CUChar -> IO () #
Storable CUInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUInt -> Int # alignment :: CUInt -> Int # peekElemOff :: Ptr CUInt -> Int -> IO CUInt # pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () # peekByteOff :: Ptr b -> Int -> IO CUInt # pokeByteOff :: Ptr b -> Int -> CUInt -> IO () # peek :: Ptr CUInt -> IO CUInt # poke :: Ptr CUInt -> CUInt -> IO () #
Storable CUIntMax
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUIntMax -> Int # alignment :: CUIntMax -> Int # peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax # pokeElemOff :: Ptr CUIntMax -> Int -> CUIntMax -> IO () # peekByteOff :: Ptr b -> Int -> IO CUIntMax # pokeByteOff :: Ptr b -> Int -> CUIntMax -> IO () # peek :: Ptr CUIntMax -> IO CUIntMax # poke :: Ptr CUIntMax -> CUIntMax -> IO () #
Storable CUIntPtr
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUIntPtr -> Int # alignment :: CUIntPtr -> Int # peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr # pokeElemOff :: Ptr CUIntPtr -> Int -> CUIntPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO CUIntPtr # pokeByteOff :: Ptr b -> Int -> CUIntPtr -> IO () # peek :: Ptr CUIntPtr -> IO CUIntPtr # poke :: Ptr CUIntPtr -> CUIntPtr -> IO () #
Storable CULLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULLong -> Int # alignment :: CULLong -> Int # peekElemOff :: Ptr CULLong -> Int -> IO CULLong # pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULLong # pokeByteOff :: Ptr b -> Int -> CULLong -> IO () # peek :: Ptr CULLong -> IO CULLong # poke :: Ptr CULLong -> CULLong -> IO () #
Storable CULong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULong -> Int # alignment :: CULong -> Int # peekElemOff :: Ptr CULong -> Int -> IO CULong # pokeElemOff :: Ptr CULong -> Int -> CULong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULong # pokeByteOff :: Ptr b -> Int -> CULong -> IO () # peek :: Ptr CULong -> IO CULong # poke :: Ptr CULong -> CULong -> IO () #
Storable CUSeconds
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUSeconds -> Int # alignment :: CUSeconds -> Int # peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds # pokeElemOff :: Ptr CUSeconds -> Int -> CUSeconds -> IO () # peekByteOff :: Ptr b -> Int -> IO CUSeconds # pokeByteOff :: Ptr b -> Int -> CUSeconds -> IO () # peek :: Ptr CUSeconds -> IO CUSeconds # poke :: Ptr CUSeconds -> CUSeconds -> IO () #
Storable CUShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUShort -> Int # alignment :: CUShort -> Int # peekElemOff :: Ptr CUShort -> Int -> IO CUShort # pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CUShort # pokeByteOff :: Ptr b -> Int -> CUShort -> IO () # peek :: Ptr CUShort -> IO CUShort # poke :: Ptr CUShort -> CUShort -> IO () #
Storable CWchar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CWchar -> Int # alignment :: CWchar -> Int # peekElemOff :: Ptr CWchar -> Int -> IO CWchar # pokeElemOff :: Ptr CWchar -> Int -> CWchar -> IO () # peekByteOff :: Ptr b -> Int -> IO CWchar # pokeByteOff :: Ptr b -> Int -> CWchar -> IO () # peek :: Ptr CWchar -> IO CWchar # poke :: Ptr CWchar -> CWchar -> IO () #
Storable IntPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: IntPtr -> Int # alignment :: IntPtr -> Int # peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr # pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO IntPtr # pokeByteOff :: Ptr b -> Int -> IntPtr -> IO () # peek :: Ptr IntPtr -> IO IntPtr # poke :: Ptr IntPtr -> IntPtr -> IO () #
Storable WordPtr
Instance details Defined in Foreign.Ptr Methods sizeOf :: WordPtr -> Int # alignment :: WordPtr -> Int # peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr # pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO WordPtr # pokeByteOff :: Ptr b -> Int -> WordPtr -> IO () # peek :: Ptr WordPtr -> IO WordPtr # poke :: Ptr WordPtr -> WordPtr -> IO () #
Storable Fingerprint	Since: base-4.4.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Fingerprint -> Int # alignment :: Fingerprint -> Int # peekElemOff :: Ptr Fingerprint -> Int -> IO Fingerprint # pokeElemOff :: Ptr Fingerprint -> Int -> Fingerprint -> IO () # peekByteOff :: Ptr b -> Int -> IO Fingerprint # pokeByteOff :: Ptr b -> Int -> Fingerprint -> IO () # peek :: Ptr Fingerprint -> IO Fingerprint # poke :: Ptr Fingerprint -> Fingerprint -> IO () #
Storable Int16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Storable Int32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Storable Int64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Storable Int8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Storable IoSubSystem	Since: base-4.9.0.0
Instance details Defined in GHC.RTS.Flags Methods sizeOf :: IoSubSystem -> Int # alignment :: IoSubSystem -> Int # peekElemOff :: Ptr IoSubSystem -> Int -> IO IoSubSystem # pokeElemOff :: Ptr IoSubSystem -> Int -> IoSubSystem -> IO () # peekByteOff :: Ptr b -> Int -> IO IoSubSystem # pokeByteOff :: Ptr b -> Int -> IoSubSystem -> IO () # peek :: Ptr IoSubSystem -> IO IoSubSystem # poke :: Ptr IoSubSystem -> IoSubSystem -> IO () #
Storable Word16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Storable Word32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Storable Word64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Storable Word8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Storable CBlkCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CBlkCnt -> Int # alignment :: CBlkCnt -> Int # peekElemOff :: Ptr CBlkCnt -> Int -> IO CBlkCnt # pokeElemOff :: Ptr CBlkCnt -> Int -> CBlkCnt -> IO () # peekByteOff :: Ptr b -> Int -> IO CBlkCnt # pokeByteOff :: Ptr b -> Int -> CBlkCnt -> IO () # peek :: Ptr CBlkCnt -> IO CBlkCnt # poke :: Ptr CBlkCnt -> CBlkCnt -> IO () #
Storable CBlkSize
Instance details Defined in System.Posix.Types Methods sizeOf :: CBlkSize -> Int # alignment :: CBlkSize -> Int # peekElemOff :: Ptr CBlkSize -> Int -> IO CBlkSize # pokeElemOff :: Ptr CBlkSize -> Int -> CBlkSize -> IO () # peekByteOff :: Ptr b -> Int -> IO CBlkSize # pokeByteOff :: Ptr b -> Int -> CBlkSize -> IO () # peek :: Ptr CBlkSize -> IO CBlkSize # poke :: Ptr CBlkSize -> CBlkSize -> IO () #
Storable CCc
Instance details Defined in System.Posix.Types Methods sizeOf :: CCc -> Int # alignment :: CCc -> Int # peekElemOff :: Ptr CCc -> Int -> IO CCc # pokeElemOff :: Ptr CCc -> Int -> CCc -> IO () # peekByteOff :: Ptr b -> Int -> IO CCc # pokeByteOff :: Ptr b -> Int -> CCc -> IO () # peek :: Ptr CCc -> IO CCc # poke :: Ptr CCc -> CCc -> IO () #
Storable CClockId
Instance details Defined in System.Posix.Types Methods sizeOf :: CClockId -> Int # alignment :: CClockId -> Int # peekElemOff :: Ptr CClockId -> Int -> IO CClockId # pokeElemOff :: Ptr CClockId -> Int -> CClockId -> IO () # peekByteOff :: Ptr b -> Int -> IO CClockId # pokeByteOff :: Ptr b -> Int -> CClockId -> IO () # peek :: Ptr CClockId -> IO CClockId # poke :: Ptr CClockId -> CClockId -> IO () #
Storable CDev
Instance details Defined in System.Posix.Types Methods sizeOf :: CDev -> Int # alignment :: CDev -> Int # peekElemOff :: Ptr CDev -> Int -> IO CDev # pokeElemOff :: Ptr CDev -> Int -> CDev -> IO () # peekByteOff :: Ptr b -> Int -> IO CDev # pokeByteOff :: Ptr b -> Int -> CDev -> IO () # peek :: Ptr CDev -> IO CDev # poke :: Ptr CDev -> CDev -> IO () #
Storable CFsBlkCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CFsBlkCnt -> Int # alignment :: CFsBlkCnt -> Int # peekElemOff :: Ptr CFsBlkCnt -> Int -> IO CFsBlkCnt # pokeElemOff :: Ptr CFsBlkCnt -> Int -> CFsBlkCnt -> IO () # peekByteOff :: Ptr b -> Int -> IO CFsBlkCnt # pokeByteOff :: Ptr b -> Int -> CFsBlkCnt -> IO () # peek :: Ptr CFsBlkCnt -> IO CFsBlkCnt # poke :: Ptr CFsBlkCnt -> CFsBlkCnt -> IO () #
Storable CFsFilCnt
Instance details Defined in System.Posix.Types Methods sizeOf :: CFsFilCnt -> Int # alignment :: CFsFilCnt -> Int # peekElemOff :: Ptr CFsFilCnt -> Int -> IO CFsFilCnt # pokeElemOff :: Ptr CFsFilCnt -> Int -> CFsFilCnt -> IO () # peekByteOff :: Ptr b -> Int -> IO CFsFilCnt # pokeByteOff :: Ptr b -> Int -> CFsFilCnt -> IO () # peek :: Ptr CFsFilCnt -> IO CFsFilCnt # poke :: Ptr CFsFilCnt -> CFsFilCnt -> IO () #
Storable CGid
Instance details Defined in System.Posix.Types Methods sizeOf :: CGid -> Int # alignment :: CGid -> Int # peekElemOff :: Ptr CGid -> Int -> IO CGid # pokeElemOff :: Ptr CGid -> Int -> CGid -> IO () # peekByteOff :: Ptr b -> Int -> IO CGid # pokeByteOff :: Ptr b -> Int -> CGid -> IO () # peek :: Ptr CGid -> IO CGid # poke :: Ptr CGid -> CGid -> IO () #
Storable CId
Instance details Defined in System.Posix.Types Methods sizeOf :: CId -> Int # alignment :: CId -> Int # peekElemOff :: Ptr CId -> Int -> IO CId # pokeElemOff :: Ptr CId -> Int -> CId -> IO () # peekByteOff :: Ptr b -> Int -> IO CId # pokeByteOff :: Ptr b -> Int -> CId -> IO () # peek :: Ptr CId -> IO CId # poke :: Ptr CId -> CId -> IO () #
Storable CIno
Instance details Defined in System.Posix.Types Methods sizeOf :: CIno -> Int # alignment :: CIno -> Int # peekElemOff :: Ptr CIno -> Int -> IO CIno # pokeElemOff :: Ptr CIno -> Int -> CIno -> IO () # peekByteOff :: Ptr b -> Int -> IO CIno # pokeByteOff :: Ptr b -> Int -> CIno -> IO () # peek :: Ptr CIno -> IO CIno # poke :: Ptr CIno -> CIno -> IO () #
Storable CKey
Instance details Defined in System.Posix.Types Methods sizeOf :: CKey -> Int # alignment :: CKey -> Int # peekElemOff :: Ptr CKey -> Int -> IO CKey # pokeElemOff :: Ptr CKey -> Int -> CKey -> IO () # peekByteOff :: Ptr b -> Int -> IO CKey # pokeByteOff :: Ptr b -> Int -> CKey -> IO () # peek :: Ptr CKey -> IO CKey # poke :: Ptr CKey -> CKey -> IO () #
Storable CMode
Instance details Defined in System.Posix.Types Methods sizeOf :: CMode -> Int # alignment :: CMode -> Int # peekElemOff :: Ptr CMode -> Int -> IO CMode # pokeElemOff :: Ptr CMode -> Int -> CMode -> IO () # peekByteOff :: Ptr b -> Int -> IO CMode # pokeByteOff :: Ptr b -> Int -> CMode -> IO () # peek :: Ptr CMode -> IO CMode # poke :: Ptr CMode -> CMode -> IO () #
Storable CNfds
Instance details Defined in System.Posix.Types Methods sizeOf :: CNfds -> Int # alignment :: CNfds -> Int # peekElemOff :: Ptr CNfds -> Int -> IO CNfds # pokeElemOff :: Ptr CNfds -> Int -> CNfds -> IO () # peekByteOff :: Ptr b -> Int -> IO CNfds # pokeByteOff :: Ptr b -> Int -> CNfds -> IO () # peek :: Ptr CNfds -> IO CNfds # poke :: Ptr CNfds -> CNfds -> IO () #
Storable CNlink
Instance details Defined in System.Posix.Types Methods sizeOf :: CNlink -> Int # alignment :: CNlink -> Int # peekElemOff :: Ptr CNlink -> Int -> IO CNlink # pokeElemOff :: Ptr CNlink -> Int -> CNlink -> IO () # peekByteOff :: Ptr b -> Int -> IO CNlink # pokeByteOff :: Ptr b -> Int -> CNlink -> IO () # peek :: Ptr CNlink -> IO CNlink # poke :: Ptr CNlink -> CNlink -> IO () #
Storable COff
Instance details Defined in System.Posix.Types Methods sizeOf :: COff -> Int # alignment :: COff -> Int # peekElemOff :: Ptr COff -> Int -> IO COff # pokeElemOff :: Ptr COff -> Int -> COff -> IO () # peekByteOff :: Ptr b -> Int -> IO COff # pokeByteOff :: Ptr b -> Int -> COff -> IO () # peek :: Ptr COff -> IO COff # poke :: Ptr COff -> COff -> IO () #
Storable CPid
Instance details Defined in System.Posix.Types Methods sizeOf :: CPid -> Int # alignment :: CPid -> Int # peekElemOff :: Ptr CPid -> Int -> IO CPid # pokeElemOff :: Ptr CPid -> Int -> CPid -> IO () # peekByteOff :: Ptr b -> Int -> IO CPid # pokeByteOff :: Ptr b -> Int -> CPid -> IO () # peek :: Ptr CPid -> IO CPid # poke :: Ptr CPid -> CPid -> IO () #
Storable CRLim
Instance details Defined in System.Posix.Types Methods sizeOf :: CRLim -> Int # alignment :: CRLim -> Int # peekElemOff :: Ptr CRLim -> Int -> IO CRLim # pokeElemOff :: Ptr CRLim -> Int -> CRLim -> IO () # peekByteOff :: Ptr b -> Int -> IO CRLim # pokeByteOff :: Ptr b -> Int -> CRLim -> IO () # peek :: Ptr CRLim -> IO CRLim # poke :: Ptr CRLim -> CRLim -> IO () #
Storable CSocklen
Instance details Defined in System.Posix.Types Methods sizeOf :: CSocklen -> Int # alignment :: CSocklen -> Int # peekElemOff :: Ptr CSocklen -> Int -> IO CSocklen # pokeElemOff :: Ptr CSocklen -> Int -> CSocklen -> IO () # peekByteOff :: Ptr b -> Int -> IO CSocklen # pokeByteOff :: Ptr b -> Int -> CSocklen -> IO () # peek :: Ptr CSocklen -> IO CSocklen # poke :: Ptr CSocklen -> CSocklen -> IO () #
Storable CSpeed
Instance details Defined in System.Posix.Types Methods sizeOf :: CSpeed -> Int # alignment :: CSpeed -> Int # peekElemOff :: Ptr CSpeed -> Int -> IO CSpeed # pokeElemOff :: Ptr CSpeed -> Int -> CSpeed -> IO () # peekByteOff :: Ptr b -> Int -> IO CSpeed # pokeByteOff :: Ptr b -> Int -> CSpeed -> IO () # peek :: Ptr CSpeed -> IO CSpeed # poke :: Ptr CSpeed -> CSpeed -> IO () #
Storable CSsize
Instance details Defined in System.Posix.Types Methods sizeOf :: CSsize -> Int # alignment :: CSsize -> Int # peekElemOff :: Ptr CSsize -> Int -> IO CSsize # pokeElemOff :: Ptr CSsize -> Int -> CSsize -> IO () # peekByteOff :: Ptr b -> Int -> IO CSsize # pokeByteOff :: Ptr b -> Int -> CSsize -> IO () # peek :: Ptr CSsize -> IO CSsize # poke :: Ptr CSsize -> CSsize -> IO () #
Storable CTcflag
Instance details Defined in System.Posix.Types Methods sizeOf :: CTcflag -> Int # alignment :: CTcflag -> Int # peekElemOff :: Ptr CTcflag -> Int -> IO CTcflag # pokeElemOff :: Ptr CTcflag -> Int -> CTcflag -> IO () # peekByteOff :: Ptr b -> Int -> IO CTcflag # pokeByteOff :: Ptr b -> Int -> CTcflag -> IO () # peek :: Ptr CTcflag -> IO CTcflag # poke :: Ptr CTcflag -> CTcflag -> IO () #
Storable CTimer
Instance details Defined in System.Posix.Types Methods sizeOf :: CTimer -> Int # alignment :: CTimer -> Int # peekElemOff :: Ptr CTimer -> Int -> IO CTimer # pokeElemOff :: Ptr CTimer -> Int -> CTimer -> IO () # peekByteOff :: Ptr b -> Int -> IO CTimer # pokeByteOff :: Ptr b -> Int -> CTimer -> IO () # peek :: Ptr CTimer -> IO CTimer # poke :: Ptr CTimer -> CTimer -> IO () #
Storable CUid
Instance details Defined in System.Posix.Types Methods sizeOf :: CUid -> Int # alignment :: CUid -> Int # peekElemOff :: Ptr CUid -> Int -> IO CUid # pokeElemOff :: Ptr CUid -> Int -> CUid -> IO () # peekByteOff :: Ptr b -> Int -> IO CUid # pokeByteOff :: Ptr b -> Int -> CUid -> IO () # peek :: Ptr CUid -> IO CUid # poke :: Ptr CUid -> CUid -> IO () #
Storable Fd
Instance details Defined in System.Posix.Types Methods sizeOf :: Fd -> Int # alignment :: Fd -> Int # peekElemOff :: Ptr Fd -> Int -> IO Fd # pokeElemOff :: Ptr Fd -> Int -> Fd -> IO () # peekByteOff :: Ptr b -> Int -> IO Fd # pokeByteOff :: Ptr b -> Int -> Fd -> IO () # peek :: Ptr Fd -> IO Fd # poke :: Ptr Fd -> Fd -> IO () #
Storable UUID	This `Storable` instance uses the memory layout as described in RFC 4122, but in contrast to the `Binary` instance, the fields are stored in host byte order.
Instance details Defined in Data.UUID.Types.Internal Methods sizeOf :: UUID -> Int # alignment :: UUID -> Int # peekElemOff :: Ptr UUID -> Int -> IO UUID # pokeElemOff :: Ptr UUID -> Int -> UUID -> IO () # peekByteOff :: Ptr b -> Int -> IO UUID # pokeByteOff :: Ptr b -> Int -> UUID -> IO () # peek :: Ptr UUID -> IO UUID # poke :: Ptr UUID -> UUID -> IO () #
Storable ()	Since: base-4.9.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: () -> Int # alignment :: () -> Int # peekElemOff :: Ptr () -> Int -> IO () # pokeElemOff :: Ptr () -> Int -> () -> IO () # peekByteOff :: Ptr b -> Int -> IO () # pokeByteOff :: Ptr b -> Int -> () -> IO () # peek :: Ptr () -> IO () # poke :: Ptr () -> () -> IO () #
Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int # alignment :: Char -> Int # peekElemOff :: Ptr Char -> Int -> IO Char # pokeElemOff :: Ptr Char -> Int -> Char -> IO () # peekByteOff :: Ptr b -> Int -> IO Char # pokeByteOff :: Ptr b -> Int -> Char -> IO () # peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int # alignment :: Word -> Int # peekElemOff :: Ptr Word -> Int -> IO Word # pokeElemOff :: Ptr Word -> Int -> Word -> IO () # peekByteOff :: Ptr b -> Int -> IO Word # pokeByteOff :: Ptr b -> Int -> Word -> IO () # peek :: Ptr Word -> IO Word # poke :: Ptr Word -> Word -> IO () #
Storable a => Storable (Complex a)	Since: base-4.8.0.0
Instance details Defined in Data.Complex Methods sizeOf :: Complex a -> Int # alignment :: Complex a -> Int # peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) # pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Complex a) # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () # peek :: Ptr (Complex a) -> IO (Complex a) # poke :: Ptr (Complex a) -> Complex a -> IO () #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Storable a => Storable (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods sizeOf :: Down a -> Int # alignment :: Down a -> Int # peekElemOff :: Ptr (Down a) -> Int -> IO (Down a) # pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Down a) # pokeByteOff :: Ptr b -> Int -> Down a -> IO () # peek :: Ptr (Down a) -> IO (Down a) # poke :: Ptr (Down a) -> Down a -> IO () #
Storable (ConstPtr a)
Instance details Defined in Foreign.Storable Methods sizeOf :: ConstPtr a -> Int # alignment :: ConstPtr a -> Int # peekElemOff :: Ptr (ConstPtr a) -> Int -> IO (ConstPtr a) # pokeElemOff :: Ptr (ConstPtr a) -> Int -> ConstPtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (ConstPtr a) # pokeByteOff :: Ptr b -> Int -> ConstPtr a -> IO () # peek :: Ptr (ConstPtr a) -> IO (ConstPtr a) # poke :: Ptr (ConstPtr a) -> ConstPtr a -> IO () #
Storable (FunPtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int # alignment :: FunPtr a -> Int # peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) # pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (FunPtr a) # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () # peek :: Ptr (FunPtr a) -> IO (FunPtr a) # poke :: Ptr (FunPtr a) -> FunPtr a -> IO () #
Storable (Ptr a)	Since: base-2.1
Instance details Defined in Foreign.Storable 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 () #
(Storable a, Integral a) => Storable (Ratio a)	Since: base-4.8.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Ratio a -> Int # alignment :: Ratio a -> Int # peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) # pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ratio a) # pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () # peek :: Ptr (Ratio a) -> IO (Ratio a) # poke :: Ptr (Ratio a) -> Ratio a -> IO () #
Storable (StablePtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: StablePtr a -> Int # alignment :: StablePtr a -> Int # peekElemOff :: Ptr (StablePtr a) -> Int -> IO (StablePtr a) # pokeElemOff :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (StablePtr a) # pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO () # peek :: Ptr (StablePtr a) -> IO (StablePtr a) # poke :: Ptr (StablePtr a) -> StablePtr a -> IO () #
Prim a => Storable (PrimStorable a)
Instance details Defined in Data.Primitive.Types Methods sizeOf :: PrimStorable a -> Int # alignment :: PrimStorable a -> Int # peekElemOff :: Ptr (PrimStorable a) -> Int -> IO (PrimStorable a) # pokeElemOff :: Ptr (PrimStorable a) -> Int -> PrimStorable a -> IO () # peekByteOff :: Ptr b -> Int -> IO (PrimStorable a) # pokeByteOff :: Ptr b -> Int -> PrimStorable a -> IO () # peek :: Ptr (PrimStorable a) -> IO (PrimStorable a) # poke :: Ptr (PrimStorable a) -> PrimStorable a -> IO () #
Storable g => Storable (StateGen g)
Instance details Defined in System.Random.Internal Methods sizeOf :: StateGen g -> Int # alignment :: StateGen g -> Int # peekElemOff :: Ptr (StateGen g) -> Int -> IO (StateGen g) # pokeElemOff :: Ptr (StateGen g) -> Int -> StateGen g -> IO () # peekByteOff :: Ptr b -> Int -> IO (StateGen g) # pokeByteOff :: Ptr b -> Int -> StateGen g -> IO () # peek :: Ptr (StateGen g) -> IO (StateGen g) # poke :: Ptr (StateGen g) -> StateGen g -> IO () #
Storable g => Storable (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: AtomicGen g -> Int # alignment :: AtomicGen g -> Int # peekElemOff :: Ptr (AtomicGen g) -> Int -> IO (AtomicGen g) # pokeElemOff :: Ptr (AtomicGen g) -> Int -> AtomicGen g -> IO () # peekByteOff :: Ptr b -> Int -> IO (AtomicGen g) # pokeByteOff :: Ptr b -> Int -> AtomicGen g -> IO () # peek :: Ptr (AtomicGen g) -> IO (AtomicGen g) # poke :: Ptr (AtomicGen g) -> AtomicGen g -> IO () #
Storable g => Storable (IOGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: IOGen g -> Int # alignment :: IOGen g -> Int # peekElemOff :: Ptr (IOGen g) -> Int -> IO (IOGen g) # pokeElemOff :: Ptr (IOGen g) -> Int -> IOGen g -> IO () # peekByteOff :: Ptr b -> Int -> IO (IOGen g) # pokeByteOff :: Ptr b -> Int -> IOGen g -> IO () # peek :: Ptr (IOGen g) -> IO (IOGen g) # poke :: Ptr (IOGen g) -> IOGen g -> IO () #
Storable g => Storable (STGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: STGen g -> Int # alignment :: STGen g -> Int # peekElemOff :: Ptr (STGen g) -> Int -> IO (STGen g) # pokeElemOff :: Ptr (STGen g) -> Int -> STGen g -> IO () # peekByteOff :: Ptr b -> Int -> IO (STGen g) # pokeByteOff :: Ptr b -> Int -> STGen g -> IO () # peek :: Ptr (STGen g) -> IO (STGen g) # poke :: Ptr (STGen g) -> STGen g -> IO () #
Storable g => Storable (TGen g)
Instance details Defined in System.Random.Stateful Methods sizeOf :: TGen g -> Int # alignment :: TGen g -> Int # peekElemOff :: Ptr (TGen g) -> Int -> IO (TGen g) # pokeElemOff :: Ptr (TGen g) -> Int -> TGen g -> IO () # peekByteOff :: Ptr b -> Int -> IO (TGen g) # pokeByteOff :: Ptr b -> Int -> TGen g -> IO () # peek :: Ptr (TGen g) -> IO (TGen g) # poke :: Ptr (TGen g) -> TGen g -> IO () #
Storable a => Storable (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int # alignment :: Const a b -> Int # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () # peek :: Ptr (Const a b) -> IO (Const a b) # poke :: Ptr (Const a b) -> Const a b -> IO () #
Storable a => Storable (Tagged s a)
Instance details Defined in Data.Tagged Methods sizeOf :: Tagged s a -> Int # alignment :: Tagged s a -> Int # peekElemOff :: Ptr (Tagged s a) -> Int -> IO (Tagged s a) # pokeElemOff :: Ptr (Tagged s a) -> Int -> Tagged s a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tagged s a) # pokeByteOff :: Ptr b -> Int -> Tagged s a -> IO () # peek :: Ptr (Tagged s a) -> IO (Tagged s a) # poke :: Ptr (Tagged s a) -> Tagged s a -> IO () #

length :: Storable a => Vector a -> Int #

head :: Storable a => Vector a -> a #

group :: (Storable a, Eq a) => Vector a -> [Vector a] #

groupBy :: Storable a => (a -> a -> Bool) -> Vector a -> [Vector a] #

foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a #

foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a #

mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b) #

forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b) #

mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m () #

forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m () #

foldMap :: (Monoid m, Storable a) => (a -> m) -> Vector a -> m #

filter :: Storable a => (a -> Bool) -> Vector a -> Vector a #

unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a #

enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a #

enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a #

fromList :: Storable a => [a] -> Vector a #

fromListN :: Storable a => Int -> [a] -> Vector a #

toList :: Storable a => Vector a -> [a] #

empty :: Storable a => Vector a #

uncons :: Storable a => Vector a -> Maybe (a, Vector a) #

unsnoc :: Storable a => Vector a -> Maybe (Vector a, a) #

tail :: Storable a => Vector a -> Vector a #

last :: Storable a => Vector a -> a #

init :: Storable a => Vector a -> Vector a #

null :: Storable a => Vector a -> Bool #

foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a #

sum :: (Storable a, Num a) => Vector a -> a #

product :: (Storable a, Num a) => Vector a -> a #

scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a #

scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

foldr' :: Storable a => (a -> b -> b) -> b -> Vector a -> b #

foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a #

scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a #

maximum :: (Storable a, Ord a) => Vector a -> a #

minimum :: (Storable a, Ord a) => Vector a -> a #

replicate :: Storable a => Int -> a -> Vector a #

takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a #

dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a #

take :: Storable a => Int -> Vector a -> Vector a #

drop :: Storable a => Int -> Vector a -> Vector a #

splitAt :: Storable a => Int -> Vector a -> (Vector a, Vector a) #

span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

reverse :: Storable a => Vector a -> Vector a #

and :: Vector Bool -> Bool #

or :: Vector Bool -> Bool #

any :: Storable a => (a -> Bool) -> Vector a -> Bool #

all :: Storable a => (a -> Bool) -> Vector a -> Bool #

elem :: (Storable a, Eq a) => a -> Vector a -> Bool #

notElem :: (Storable a, Eq a) => a -> Vector a -> Bool #

concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b #

zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c #

zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d #

unsafeIndex :: Storable a => Vector a -> Int -> a #

foldMap' :: (Monoid m, Storable a) => (a -> m) -> Vector a -> m #

find :: Storable a => (a -> Bool) -> Vector a -> Maybe a #

elemIndex :: (Storable a, Eq a) => a -> Vector a -> Maybe Int #

elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int #

findIndex :: Storable a => (a -> Bool) -> Vector a -> Maybe Int #

findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int #

partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e #

zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f #

zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g #

singleton :: Storable a => a -> Vector a #

filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a) #

zipWithM :: (Monad m, Storable a, Storable b, Storable c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c) #

zipWithM_ :: (Monad m, Storable a, Storable b) => (a -> b -> m c) -> Vector a -> Vector b -> m () #

foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a #

foldM_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m () #

replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a) #

cons :: Storable a => a -> Vector a -> Vector a #

foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a #

copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m () #

snoc :: Storable a => Vector a -> a -> Vector a #

create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a #

unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a #

unsafeHead :: Storable a => Vector a -> a #

unsafeTail :: Storable a => Vector a -> Vector a #

unsafeInit :: Storable a => Vector a -> Vector a #

unsafeLast :: Storable a => Vector a -> a #

unsafeTake :: Storable a => Int -> Vector a -> Vector a #

unsafeDrop :: Storable a => Int -> Vector a -> Vector a #

iterateN :: Storable a => Int -> (a -> a) -> a -> Vector a #

findIndexR :: Storable a => (a -> Bool) -> Vector a -> Maybe Int #

force :: Storable a => Vector a -> Vector a #

ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b #

ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a #

ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b #

ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a #

imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b #

imapM :: (Monad m, Storable a, Storable b) => (Int -> a -> m b) -> Vector a -> m (Vector b) #

iforM :: (Monad m, Storable a, Storable b) => Vector a -> (Int -> a -> m b) -> m (Vector b) #

imapM_ :: (Monad m, Storable a) => (Int -> a -> m b) -> Vector a -> m () #

iforM_ :: (Monad m, Storable a) => Vector a -> (Int -> a -> m b) -> m () #

modify :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a #

indexM :: (Storable a, Monad m) => Vector a -> Int -> m a #

generate :: Storable a => Int -> (Int -> a) -> Vector a #

generateM :: (Monad m, Storable a) => Int -> (Int -> m a) -> m (Vector a) #

slice :: Storable a => Int -> Int -> Vector a -> Vector a #

eqBy :: (Storable a, Storable b) => (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

cmpBy :: (Storable a, Storable b) => (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering #

mapMaybeM :: (Monad m, Storable a, Storable b) => (a -> m (Maybe b)) -> Vector a -> m (Vector b) #

uniq :: (Storable a, Eq a) => Vector a -> Vector a #

fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a #

foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a #

fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a #

unfoldrM :: (Monad m, Storable a) => (b -> m (Maybe (a, b))) -> b -> m (Vector a) #

unfoldrNM :: (Monad m, Storable a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a) #

unfoldrExactN :: Storable a => Int -> (b -> (a, b)) -> b -> Vector a #

unfoldrExactNM :: (Monad m, Storable a) => Int -> (b -> m (a, b)) -> b -> m (Vector a) #

iterateNM :: (Monad m, Storable a) => Int -> (a -> m a) -> a -> m (Vector a) #

prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a #

scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a #

enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a #

data Vector a #

Instances

Instances details

NFData1 Vector

Instance details

Defined in Data.Vector.Storable

Methods

liftRnf :: (a -> ()) -> Vector a -> () #

Storable a => Vector Vector a

Instance details

Defined in Data.Vector.Storable

Methods

basicUnsafeFreeze :: Mutable Vector s a -> ST s (Vector a) #

basicUnsafeThaw :: Vector a -> ST s (Mutable Vector s a) #

basicLength :: Vector a -> Int #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a #

basicUnsafeIndexM :: Vector a -> Int -> Box a #

basicUnsafeCopy :: Mutable Vector s a -> Vector a -> ST s () #

elemseq :: Vector a -> a -> b -> b #

(Data a, Storable a) => Data (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

Storable a => Monoid (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

Storable a => Semigroup (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

(<>) :: Vector a -> Vector a -> Vector a #

sconcat :: NonEmpty (Vector a) -> Vector a #

stimes :: Integral b => b -> Vector a -> Vector a #

Storable a => IsList (Vector a)

Instance details

Defined in Data.Vector.Storable

Associated Types

type Item (Vector a)
Instance details Defined in Data.Vector.Storable type Item (Vector a) = a

Methods

fromList :: [Item (Vector a)] -> Vector a #

fromListN :: Int -> [Item (Vector a)] -> Vector a #

toList :: Vector a -> [Item (Vector a)] #

(Read a, Storable a) => Read (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

readsPrec :: Int -> ReadS (Vector a) #

readList :: ReadS [Vector a] #

readPrec :: ReadPrec (Vector a) #

readListPrec :: ReadPrec [Vector a] #

(Show a, Storable a) => Show (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

showsPrec :: Int -> Vector a -> ShowS #

show :: Vector a -> String #

showList :: [Vector a] -> ShowS #

NFData (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

rnf :: Vector a -> () #

(Storable a, Eq a) => Eq (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

(==) :: Vector a -> Vector a -> Bool #

(/=) :: Vector a -> Vector a -> Bool #

(Storable a, Ord a) => Ord (Vector a)

Instance details

Defined in Data.Vector.Storable

Methods

compare :: Vector a -> Vector a -> Ordering #

(<) :: Vector a -> Vector a -> Bool #

(<=) :: Vector a -> Vector a -> Bool #

(>) :: Vector a -> Vector a -> Bool #

(>=) :: Vector a -> Vector a -> Bool #

max :: Vector a -> Vector a -> Vector a #

min :: Vector a -> Vector a -> Vector a #

type Mutable Vector

Instance details

Defined in Data.Vector.Storable

type Mutable Vector = MVector

type Item (Vector a)

Instance details

Defined in Data.Vector.Storable

type Item (Vector a) = a

convert :: (Vector v a, Vector w a) => v a -> w a #

accumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #

backpermute :: Storable a => Vector a -> Vector Int -> Vector a #

breakR :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

constructN :: Storable a => Int -> (Vector a -> a) -> Vector a #

constructrN :: Storable a => Int -> (Vector a -> a) -> Vector a #

createT :: (Traversable f, Storable a) => (forall s. ST s (f (MVector s a))) -> f (Vector a) #

enumFromN :: (Storable a, Num a) => a -> Int -> Vector a #

fold1M'_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m () #

fold1M_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m () #

foldM'_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m () #

headM :: (Storable a, Monad m) => Vector a -> m a #

ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a #

ifoldM :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a #

ifoldM' :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a #

ifoldM'_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m () #

ifoldM_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m () #

imapMaybe :: (Storable a, Storable b) => (Int -> a -> Maybe b) -> Vector a -> Vector b #

imapMaybeM :: (Monad m, Storable a, Storable b) => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b) #

iscanl :: (Storable a, Storable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a #

iscanl' :: (Storable a, Storable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a #

iscanr :: (Storable a, Storable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b #

iscanr' :: (Storable a, Storable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b #

izipWith :: (Storable a, Storable b, Storable c) => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c #

izipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d #

izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e #

izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f #

izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g #

izipWithM :: (Monad m, Storable a, Storable b, Storable c) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c) #

izipWithM_ :: (Monad m, Storable a, Storable b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m () #

lastM :: (Storable a, Monad m) => Vector a -> m a #

maxIndex :: (Storable a, Ord a) => Vector a -> Int #

maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int #

maximumOn :: (Ord b, Storable a) => (a -> b) -> Vector a -> a #

minIndex :: (Storable a, Ord a) => Vector a -> Int #

minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int #

minimumOn :: (Ord b, Storable a) => (a -> b) -> Vector a -> a #

partitionWith :: (Storable a, Storable b, Storable c) => (a -> Either b c) -> Vector a -> (Vector b, Vector c) #

postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b #

scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a #

spanR :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

unsafeAccumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #

unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a #

unsafeCopy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m () #

unsafeHeadM :: (Storable a, Monad m) => Vector a -> m a #

unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a #

unsafeLastM :: (Storable a, Monad m) => Vector a -> m a #

unsafeSlice :: Storable a => Int -> Int -> Vector a -> Vector a #

unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a #

unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a #

unstablePartition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

update_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a #

data MVector s a #

Constructors

MVector !Int !(ForeignPtr a)

Instances

Instances details

Storable a => MVector MVector a
Instance details Defined in Data.Vector.Storable.Mutable Methods basicLength :: MVector s a -> Int # basicUnsafeSlice :: Int -> Int -> MVector s a -> MVector s a # basicOverlaps :: MVector s a -> MVector s a -> Bool # basicUnsafeNew :: Int -> ST s (MVector s a) # basicInitialize :: MVector s a -> ST s () # basicUnsafeReplicate :: Int -> a -> ST s (MVector s a) # basicUnsafeRead :: MVector s a -> Int -> ST s a # basicUnsafeWrite :: MVector s a -> Int -> a -> ST s () # basicClear :: MVector s a -> ST s () # basicSet :: MVector s a -> a -> ST s () # basicUnsafeCopy :: MVector s a -> MVector s a -> ST s () # basicUnsafeMove :: MVector s a -> MVector s a -> ST s () # basicUnsafeGrow :: MVector s a -> Int -> ST s (MVector s a) #
NFData1 (MVector s)
Instance details Defined in Data.Vector.Storable.Mutable Methods liftRnf :: (a -> ()) -> MVector s a -> () #
NFData (MVector s a)
Instance details Defined in Data.Vector.Storable.Mutable Methods rnf :: MVector s a -> () #

unsafeCast :: (Storable a, Storable b) => Vector a -> Vector b #

unsafeCoerceVector :: Coercible a b => Vector a -> Vector b #

unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Int -> Int -> Vector a #

isSameVector :: Storable a => Vector a -> Vector a -> Bool #

unsafeFromForeignPtr0 :: ForeignPtr a -> Int -> Vector a #

unsafeToForeignPtr :: Vector a -> (ForeignPtr a, Int, Int) #

unsafeToForeignPtr0 :: Vector a -> (ForeignPtr a, Int) #

unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b #