vector-0.13.2.0: Efficient Arrays

Copyright | (c) Roman Leshchinskiy 2009-2010 Alexey Kuleshevich 2020-2022 Aleksey Khudyakov 2020-2022 Andrew Lelechenko 2020-2022
License | BSD-style
Maintainer | Haskell Libraries Team <libraries@haskell.org>
Stability | experimental
Portability | non-portable
Safe Haskell | None
Language | Haskell2010

Data.Vector.Storable.Mutable

Contents

- Mutable vectors of `Storable` types
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Accessing individual elements
- Folds
- Modifying vectors
  - Filling and copying
- Unsafe conversions
- Raw pointers
- Re-exports

Description

Mutable vectors based on Storable.

Synopsis

- data MVector s a = MVector !Int !(ForeignPtr a)
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- length :: Storable a => MVector s a -> Int
- null :: Storable a => MVector s a -> Bool
- slice :: Storable a => Int -> Int -> MVector s a -> MVector s a
- init :: Storable a => MVector s a -> MVector s a
- tail :: Storable a => MVector s a -> MVector s a
- take :: Storable a => Int -> MVector s a -> MVector s a
- drop :: Storable a => Int -> MVector s a -> MVector s a
- splitAt :: Storable a => Int -> MVector s a -> (MVector s a, MVector s a)
- unsafeSlice :: Storable a => Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: Storable a => MVector s a -> MVector s a
- unsafeTail :: Storable a => MVector s a -> MVector s a
- unsafeTake :: Storable a => Int -> MVector s a -> MVector s a
- unsafeDrop :: Storable a => Int -> MVector s a -> MVector s a
- overlaps :: Storable a => MVector s a -> MVector s a -> Bool
- new :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
- unsafeNew :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: (PrimMonad m, Storable a) => Int -> m a -> m (MVector (PrimState m) a)
- generate :: (PrimMonad m, Storable a) => Int -> (Int -> a) -> m (MVector (PrimState m) a)
- generateM :: (PrimMonad m, Storable a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a)
- clone :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- unsafeGrow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m ()
- read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
- readMaybe :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (Maybe a)
- write :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m ()
- modify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- modifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m ()
- swap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m ()
- exchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a
- unsafeRead :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeModify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- unsafeModifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m ()
- unsafeSwap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m ()
- unsafeExchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a
- mapM_ :: (PrimMonad m, Storable a) => (a -> m b) -> MVector (PrimState m) a -> m ()
- imapM_ :: (PrimMonad m, Storable a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m ()
- forM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m b) -> m ()
- iforM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m ()
- foldl :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b
- foldl' :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b
- foldM :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- foldM' :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- foldr :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- foldr' :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- foldrM :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- foldrM' :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldl :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldl' :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldM :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldM' :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldr :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldr' :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b
- ifoldrM :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- ifoldrM' :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b
- nextPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool
- nextPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool
- prevPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool
- prevPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool
- set :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCopy :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeMove :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCast :: (Storable a, Storable b) => MVector s a -> MVector s b
- unsafeCoerceMVector :: Coercible a b => MVector s a -> MVector s b
- unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Int -> Int -> MVector s a
- unsafeFromForeignPtr0 :: ForeignPtr a -> Int -> MVector s a
- unsafeToForeignPtr :: MVector s a -> (ForeignPtr a, Int, Int)
- unsafeToForeignPtr0 :: MVector s a -> (ForeignPtr a, Int)
- unsafeWith :: Storable a => IOVector a -> (Ptr a -> IO b) -> IO b
- class Storable a
- class Monad m => PrimMonad (m :: Type -> Type)
- type family PrimState (m :: Type -> Type)
- data RealWorld

# Mutable vectors of `Storable` types

data MVector s a #

Mutable `Storable`-based vectors.

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

type IOVector = MVector RealWorld #

type STVector s = MVector s #

# Accessors

## Length information

length :: Storable a => MVector s a -> Int #

Length of the mutable vector.

null :: Storable a => MVector s a -> Bool #

Check whether the vector is empty.

## Extracting subvectors

slice #

Arguments

:: Storable a |
=> Int | `i` starting index
-> Int | `n` length
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. The vector must contain at least `i+n` elements.

init :: Storable a => MVector s a -> MVector s a #

Drop the last element of the mutable vector without making a copy. If the vector is empty, an exception is thrown.

tail :: Storable a => MVector s a -> MVector s a #

Drop the first element of the mutable vector without making a copy. If the vector is empty, an exception is thrown.

take :: Storable a => Int -> MVector s a -> MVector s a #

Take the `n` first elements of the mutable vector without making a copy. For negative `n`, the empty vector is returned. If `n` is larger than the vector's length, the vector is returned unchanged.

drop :: Storable a => Int -> MVector s a -> MVector s a #

Drop the `n` first element of the mutable vector without making a copy. For negative `n`, the vector is returned unchanged. If `n` is larger than the vector's length, the empty vector is returned.

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

O(1) Split the mutable vector into the first `n` elements and the remainder, without copying.

Note that ``splitAt` n v` is equivalent to `(`take` n v, `drop` n v)`, but slightly more efficient.

unsafeSlice #

Arguments

:: Storable a |
=> Int | starting index
-> Int | length of the slice
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. No bounds checks are performed.

unsafeInit :: Storable a => MVector s a -> MVector s a #

Same as `init`, but doesn't do range checks.

unsafeTail :: Storable a => MVector s a -> MVector s a #

Same as `tail`, but doesn't do range checks.

unsafeTake :: Storable a => Int -> MVector s a -> MVector s a #

Unsafe variant of `take`. If `n` is out of range, it will simply create an invalid slice that likely violate memory safety.

unsafeDrop :: Storable a => Int -> MVector s a -> MVector s a #

Unsafe variant of `drop`. If `n` is out of range, it will simply create an invalid slice that likely violate memory safety.

## Overlapping

overlaps :: Storable a => MVector s a -> MVector s a -> Bool #

Check whether two vectors overlap.

# Construction

## Initialisation

new :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length.

unsafeNew :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length. The vector content is uninitialized, which means it is filled with whatever the underlying memory buffer happens to contain.

Since: 0.5

replicate :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.

replicateM :: (PrimMonad m, Storable a) => Int -> m a -> m (MVector (PrimState m) a) #

Create a mutable vector of the given length (0 if the length is negative) and fill it with values produced by repeatedly executing the monadic action.

generate :: (PrimMonad m, Storable a) => Int -> (Int -> a) -> m (MVector (PrimState m) a) #

O(n) Create a mutable vector of the given length (0 if the length is negative) and fill it with the results of applying the function to each index. Iteration starts at index 0.

Since: 0.12.3.0

generateM :: (PrimMonad m, Storable a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a) #

O(n) Create a mutable vector of the given length (0 if the length is negative) and fill it with the results of applying the monadic function to each index. Iteration starts at index 0.

Since: 0.12.3.0

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

Create a copy of a mutable vector.

## Growing

grow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #

Grow a storable vector by the given number of elements. The number must be non-negative. This has the same semantics as `grow` for generic vectors.

#### Examples

Expand

    >>> import qualified Data.Vector.Storable as VS
    >>> import qualified Data.Vector.Storable.Mutable as MVS
    >>> mv <- VS.thaw $ VS.fromList ([10, 20, 30] :: [Int])
    >>> mv' <- MVS.grow mv 2

Extra memory at the end of the newly allocated vector is initialized to 0 bytes, which for `Storable` instances will usually correspond to some default value for a particular type, e.g. `0` for `Int`, `False` for `Bool`, etc. However, if `unsafeGrow` was used instead, this would not have been guaranteed and some garbage would be there instead.

    >>> VS.freeze mv'
    [10,20,30,0,0]

Having the extra space we can write new values in there:

    >>> MVS.write mv' 3 999
    >>> VS.freeze mv'
    [10,20,30,999,0]

It is important to note that the source mutable vector is not affected when the newly allocated one is mutated.

    >>> MVS.write mv' 2 888
    >>> VS.freeze mv'
    [10,20,888,999,0]
    >>> VS.freeze mv
    [10,20,30]

Since: 0.5

unsafeGrow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #

Grow a vector by the given number of elements. The number must be non-negative, but this is not checked. This has the same semantics as `unsafeGrow` for generic vectors.

Since: 0.5

## Restricting memory usage

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

Reset all elements of the vector to some undefined value, clearing all references to external objects. This is a noop.

# Accessing individual elements

read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a #

Yield the element at the given position. Will throw an exception if the index is out of range.

#### Examples

Expand

    >>> import qualified Data.Vector.Storable.Mutable as MVS
    >>> v <- MVS.generate 10 (\x -> x*x)
    >>> MVS.read v 3
    9

readMaybe :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (Maybe a) #

Yield the element at the given position. Returns `Nothing` if the index is out of range.

#### Examples

Expand

    >>> import qualified Data.Vector.Storable.Mutable as MVS
    >>> v <- MVS.generate 10 (\x -> x*x)
    >>> MVS.readMaybe v 3
    Just 9
    >>> MVS.readMaybe v 13
    Nothing

Since: 0.13

write :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () #

Replace the element at the given position.

modify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

Modify the element at the given position.

modifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () #

Modify the element at the given position using a monadic function.

Since: 0.12.3.0

swap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () #

Swap the elements at the given positions.

exchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a #

Replace the element at the given position and return the old element.

unsafeRead :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a #

Yield the element at the given position. No bounds checks are performed.

unsafeWrite :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () #

Replace the element at the given position. No bounds checks are performed.

unsafeModify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #

Modify the element at the given position. No bounds checks are performed.

unsafeModifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () #

Modify the element at the given position using a monadic function. No bounds checks are performed.

Since: 0.12.3.0

unsafeSwap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () #

Swap the elements at the given positions. No bounds checks are performed.

unsafeExchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a #

Replace the element at the given position and return the old element. No bounds checks are performed.

# Folds

mapM_ :: (PrimMonad m, Storable a) => (a -> m b) -> MVector (PrimState m) a -> m () #

O(n) Apply the monadic action to every element of the vector, discarding the results.

Since: 0.12.3.0

imapM_ :: (PrimMonad m, Storable a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m () #

O(n) Apply the monadic action to every element of the vector and its index, discarding the results.

Since: 0.12.3.0

forM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m b) -> m () #

O(n) Apply the monadic action to every element of the vector, discarding the results. It's the same as `flip mapM_`.

Since: 0.12.3.0

iforM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m () #

O(n) Apply the monadic action to every element of the vector and its index, discarding the results. It's the same as `flip imapM_`.

Since: 0.12.3.0

foldl :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold.

Since: 0.12.3.0

foldl' :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold with strict accumulator.

Since: 0.12.3.0

foldM :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold.

Since: 0.12.3.0

foldM' :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold with strict accumulator.

Since: 0.12.3.0

foldr :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold.

Since: 0.12.3.0

foldr' :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold with strict accumulator.

Since: 0.12.3.0

foldrM :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold.

Since: 0.12.3.0

foldrM' :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold with strict accumulator.

Since: 0.12.3.0

ifoldl :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldl' :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure left fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldM :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldM' :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldr :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldr' :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b #

O(n) Pure right fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

ifoldrM :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold using a function applied to each element and its index.

Since: 0.12.3.0

ifoldrM' :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b #

O(n) Monadic right fold with strict accumulator using a function applied to each element and its index.

Since: 0.12.3.0

# Modifying vectors

nextPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool #

Compute the (lexicographically) next permutation of the given vector in-place. Returns False when the input is the last item in the enumeration, i.e., if it is in weakly descending order. In this case the vector will not get updated, as opposed to the behavior of the C++ function `std::next_permutation`.

nextPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool #

Compute the (lexicographically) next permutation of the given vector in-place, using the provided comparison function. Returns False when the input is the last item in the enumeration, i.e., if it is in weakly descending order. In this case the vector will not get updated, as opposed to the behavior of the C++ function `std::next_permutation`.

Since: 0.13.2.0

prevPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool #

Compute the (lexicographically) previous permutation of the given vector in-place. Returns False when the input is the last item in the enumeration, i.e., if it is in weakly ascending order. In this case the vector will not get updated, as opposed to the behavior of the C++ function `std::prev_permutation`.

Since: 0.13.2.0

prevPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool #

Compute the (lexicographically) previous permutation of the given vector in-place, using the provided comparison function. Returns False when the input is the last item in the enumeration, i.e., if it is in weakly ascending order. In this case the vector will not get updated, as opposed to the behavior of the C++ function `std::prev_permutation`.

Since: 0.13.2.0

## Filling and copying

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

Set all elements of the vector to the given value.

copy #

Arguments

:: (PrimMonad m, Storable a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Copy a vector. The two vectors must have the same length and may not overlap.

move #

Arguments

:: (PrimMonad m, Storable a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Move the contents of a vector. The two vectors must have the same length.

If the vectors do not overlap, then this is equivalent to `copy`. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.

unsafeCopy #

Arguments

:: (PrimMonad m, Storable a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Copy a vector. The two vectors must have the same length and may not overlap, but this is not checked.

unsafeMove #

Arguments

:: (PrimMonad m, Storable a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Move the contents of a vector. The two vectors must have the same length, but this is not checked.

If the vectors do not overlap, then this is equivalent to `unsafeCopy`. Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.

# Unsafe conversions

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

O(1) Unsafely cast a mutable vector from one element type to another. The operation just changes the type of the underlying pointer and does not modify the elements.

The resulting vector contains as many elements as can fit into the underlying memory block.

unsafeCoerceMVector :: Coercible a b => MVector s a -> MVector s b #

O(1) Unsafely coerce a mutable vector from one element type to another, representationally equal type. The operation just changes the type of the underlying pointer and does not modify the elements.

This is marginally safer than `unsafeCast`, since this function imposes an extra `Coercible` constraint. This function is still not safe, however, since it cannot guarantee that the two types have memory-compatible `Storable` instances.

# Raw pointers

unsafeFromForeignPtr #

Arguments

:: Storable a |
=> ForeignPtr a | pointer
-> Int | offset
-> Int | length
-> MVector s a |

O(1) Create a mutable vector from a `ForeignPtr` with an offset and a length.

Modifying data through the `ForeignPtr` afterwards is unsafe if the vector could have been frozen before the modification.

If your offset is 0, it is more efficient to use `unsafeFromForeignPtr0`.

unsafeFromForeignPtr0 #

Arguments

:: ForeignPtr a | pointer
-> Int | length
-> MVector s a |

O(1) Create a mutable vector from a `ForeignPtr` and a length.

It is assumed that the pointer points directly to the data (no offset). Use `unsafeFromForeignPtr` if you need to specify an offset.

Modifying data through the `ForeignPtr` afterwards is unsafe if the vector could have been frozen before the modification.

unsafeToForeignPtr :: MVector s a -> (ForeignPtr a, Int, Int) #

O(1) Yield the underlying `ForeignPtr` together with the offset to the data and its length. Modifying the data through the `ForeignPtr` is unsafe if the vector could have been frozen before the modification.

unsafeToForeignPtr0 :: MVector s a -> (ForeignPtr a, Int) #

O(1) Yield the underlying `ForeignPtr` together with its length.

You can assume that the pointer points directly to the data (no offset).

Modifying the data through the `ForeignPtr` is unsafe if the vector could have been frozen before the modification.

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

Pass a pointer to the vector's data to the IO action. Modifying data through the pointer is unsafe if the vector could have been frozen before the modification.

# Re-exports

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 Fingerprint | @since base-4.4.0.0
Instance details Defined in GHC.Internal.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 CBool |
Instance details Defined in GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 Int16 | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.Internal.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 CBlkCnt |
Instance details Defined in GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 Word16 | @since base-2.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 () | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 GHC.Internal.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 GHC.Internal.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 GHC.Internal.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.01
Instance details Defined in GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 GHC.Internal.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.01
Instance details Defined in GHC.Internal.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 a => Storable (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.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 () #

class Monad m => PrimMonad (m :: Type -> Type) #

Class of monads which can perform primitive state-transformer actions.

Minimal complete definition

primitive

#### Instances

Instances details

PrimMonad IO |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState IO |
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld
Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a #
PrimMonad (ST s) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
Methods primitive :: (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)) -> ST s a #
PrimMonad (ST s) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
Methods primitive :: (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)) -> ST s a #
PrimMonad m => PrimMonad (MaybeT m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (MaybeT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m
Methods primitive :: (State# (PrimState (MaybeT m)) -> (# State# (PrimState (MaybeT m)), a #)) -> MaybeT m a #
(Monoid w, PrimMonad m) => PrimMonad (AccumT w m) | Since: primitive-0.6.3.0
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (AccumT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (AccumT w m) = PrimState m
Methods primitive :: (State# (PrimState (AccumT w m)) -> (# State# (PrimState (AccumT w m)), a #)) -> AccumT w m a #
PrimMonad m => PrimMonad (ExceptT e m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (ExceptT e m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ExceptT e m) = PrimState m
Methods primitive :: (State# (PrimState (ExceptT e m)) -> (# State# (PrimState (ExceptT e m)), a #)) -> ExceptT e m a #
PrimMonad m => PrimMonad (IdentityT m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (IdentityT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (IdentityT m) = PrimState m
Methods primitive :: (State# (PrimState (IdentityT m)) -> (# State# (PrimState (IdentityT m)), a #)) -> IdentityT m a #
PrimMonad m => PrimMonad (ReaderT r m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (ReaderT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ReaderT r m) = PrimState m
Methods primitive :: (State# (PrimState (ReaderT r m)) -> (# State# (PrimState (ReaderT r m)), a #)) -> ReaderT r m a #
PrimMonad m => PrimMonad (SelectT r m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (SelectT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (SelectT r m) = PrimState m
Methods primitive :: (State# (PrimState (SelectT r m)) -> (# State# (PrimState (SelectT r m)), a #)) -> SelectT r m a #
PrimMonad m => PrimMonad (StateT s m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
Methods primitive :: (State# (PrimState (StateT s m)) -> (# State# (PrimState (StateT s m)), a #)) -> StateT s m a #
PrimMonad m => PrimMonad (StateT s m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
Methods primitive :: (State# (PrimState (StateT s m)) -> (# State# (PrimState (StateT s m)), a #)) -> StateT s m a #
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
Methods primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
Methods primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #
(Monoid w, PrimMonad m) => PrimMonad (WriterT w m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
Methods primitive :: (State# (PrimState (WriterT w m)) -> (# State# (PrimState (WriterT w m)), a #)) -> WriterT w m a #
PrimMonad m => PrimMonad (ContT r m) | Since: primitive-0.6.3.0
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (ContT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ContT r m) = PrimState m
Methods primitive :: (State# (PrimState (ContT r m)) -> (# State# (PrimState (ContT r m)), a #)) -> ContT r m a #
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
Methods primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
Methods primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #
(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive Associated Types
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
Methods primitive :: (State# (PrimState (RWST r w s m)) -> (# State# (PrimState (RWST r w s m)), a #)) -> RWST r w s m a #

type family PrimState (m :: Type -> Type) #

State token type.

#### Instances

Instances details

type PrimState IO |
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
type PrimState (ST s) |
Instance details Defined in Control.Monad.Primitive type PrimState (ST s) = s
type PrimState (MaybeT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m
type PrimState (AccumT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (AccumT w m) = PrimState m
type PrimState (ExceptT e m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ExceptT e m) = PrimState m
type PrimState (IdentityT m) |
Instance details Defined in Control.Monad.Primitive type PrimState (IdentityT m) = PrimState m
type PrimState (ReaderT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ReaderT r m) = PrimState m
type PrimState (SelectT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (SelectT r m) = PrimState m
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
type PrimState (StateT s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (WriterT w m) |
Instance details Defined in Control.Monad.Primitive type PrimState (WriterT w m) = PrimState m
type PrimState (ContT r m) |
Instance details Defined in Control.Monad.Primitive type PrimState (ContT r m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m
type PrimState (RWST r w s m) |
Instance details Defined in Control.Monad.Primitive type PrimState (RWST r w s m) = PrimState m

data RealWorld #

`RealWorld` is deeply magical. It is primitive, but it is not unlifted (hence `ptrArg`). We never manipulate values of type `RealWorld`; it's only used in the type system, to parameterise `State#`.