vector-0.12.0.3: Efficient Arrays

Copyright | (c) Roman Leshchinskiy 2009-2010
License | BSD-style
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au>
Stability | experimental
Portability | non-portable
Safe Haskell | None
Language | Haskell2010

Data.Vector.Unboxed.Mutable

Contents

- Mutable vectors of primitive types
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Zipping and unzipping
- Accessing individual elements
- Modifying vectors
  - Filling and copying

Description

Mutable adaptive unboxed vectors

Synopsis

- data family MVector s a
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- class (Vector Vector a, MVector MVector a) => Unbox a
- length :: Unbox a => MVector s a -> Int
- null :: Unbox a => MVector s a -> Bool
- slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
- init :: Unbox a => MVector s a -> MVector s a
- tail :: Unbox a => MVector s a -> MVector s a
- take :: Unbox a => Int -> MVector s a -> MVector s a
- drop :: Unbox a => Int -> MVector s a -> MVector s a
- splitAt :: Unbox a => Int -> MVector s a -> (MVector s a, MVector s a)
- unsafeSlice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: Unbox a => MVector s a -> MVector s a
- unsafeTail :: Unbox a => MVector s a -> MVector s a
- unsafeTake :: Unbox a => Int -> MVector s a -> MVector s a
- unsafeDrop :: Unbox a => Int -> MVector s a -> MVector s a
- overlaps :: Unbox a => MVector s a -> MVector s a -> Bool
- new :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
- unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: (PrimMonad m, Unbox a) => Int -> m a -> m (MVector (PrimState m) a)
- clone :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- unsafeGrow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m ()
- zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b)
- zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c)
- zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d)
- zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e)
- zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f)
- unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, MVector s b)
- unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c)
- unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s (a, b, c, d) -> (MVector s a, MVector s b, MVector s c, MVector s d)
- unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e)
- unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e, MVector s f)
- read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
- write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
- modify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
- unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeModify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
- nextPermutation :: (PrimMonad m, Ord e, Unbox e) => MVector (PrimState m) e -> m Bool
- set :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCopy :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeMove :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()

# Mutable vectors of primitive types

data family MVector s a #

Instances

MVector MVector Bool # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool #

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) #

MVector MVector Char # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char #

basicOverlaps :: MVector s Char -> MVector s Char -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) #

MVector MVector Double # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double #

basicOverlaps :: MVector s Double -> MVector s Double -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) #

MVector MVector Float # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float #

basicOverlaps :: MVector s Float -> MVector s Float -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) #

MVector MVector Int # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int #

basicOverlaps :: MVector s Int -> MVector s Int -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) #

MVector MVector Int8 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int8 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 #

basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8) #

MVector MVector Int16 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int16 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 #

basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16) #

MVector MVector Int32 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int32 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 #

basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32) #

MVector MVector Int64 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int64 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 #

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) #

MVector MVector Word # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word #

basicOverlaps :: MVector s Word -> MVector s Word -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) #

MVector MVector Word8 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 #

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) #

MVector MVector Word16 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word16 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 #

basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16) #

MVector MVector Word32 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word32 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 #

basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32) #

MVector MVector Word64 # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word64 -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 #

basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) #

MVector MVector () # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s () -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s () #

basicOverlaps :: MVector s () -> MVector s () -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) ()) #

basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> () -> m (MVector (PrimState m) ()) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) () -> Int -> m () #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) () -> Int -> () -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) () -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ()) #

Unbox a => MVector MVector (Complex a) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Complex a) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a) #

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a)) #

(Unbox a, Unbox b) => MVector MVector (a, b) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b) #

basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool #

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

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

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

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

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

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

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

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

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

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

(Unbox a, Unbox b, Unbox c) => MVector MVector (a, b, c) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c) #

basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (a, b, c)) #

(Unbox a, Unbox b, Unbox c, Unbox d) => MVector MVector (a, b, c, d) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d) #

basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d)) #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector MVector (a, b, c, d, e) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) #

basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (a, b, c, d, e)) #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector MVector (a, b, c, d, e, f) # |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e, f) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) #

basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) #

NFData (MVector s a) # |
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () #
newtype MVector s Bool # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Bool = MV_Bool (MVector s Word8)
newtype MVector s Char # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Char = MV_Char (MVector s Char)
newtype MVector s Double # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Double = MV_Double (MVector s Double)
newtype MVector s Float # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Float = MV_Float (MVector s Float)
newtype MVector s Word64 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 (MVector s Word64)
newtype MVector s Word32 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 (MVector s Word32)
newtype MVector s Word16 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 (MVector s Word16)
newtype MVector s Word8 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 (MVector s Word8)
newtype MVector s Word # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
newtype MVector s Int64 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 (MVector s Int64)
newtype MVector s Int32 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 (MVector s Int32)
newtype MVector s Int16 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 (MVector s Int16)
newtype MVector s Int8 # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 (MVector s Int8)
newtype MVector s Int # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
newtype MVector s () # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s () = MV_Unit Int
newtype MVector s (Complex a) # |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))
data MVector s (a, b) # |
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b) = MV_2 !Int !(MVector s a) !(MVector s b)
data MVector s (a, b, c) # |
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c) = MV_3 !Int !(MVector s a) !(MVector s b) !(MVector s c)
data MVector s (a, b, c, d) # |
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d) = MV_4 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d)
data MVector s (a, b, c, d, e) # |
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d, e) = MV_5 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e)
data MVector s (a, b, c, d, e, f) # |
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d, e, f) = MV_6 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e) !(MVector s f)

type IOVector = MVector RealWorld #

type STVector s = MVector s #

class (Vector Vector a, MVector MVector a) => Unbox a #

Instances

Unbox Bool # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Char # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Double # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Float # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int8 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int16 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int32 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int64 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word8 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word16 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word32 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word64 # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox () # |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Complex a) # |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (a, b) # |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) # |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) # |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) # |
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f) # |
Instance details Defined in Data.Vector.Unboxed.Base

# Accessors

## Length information

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

Length of the mutable vector.

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

Check whether the vector is empty

## Extracting subvectors

slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a #

Yield a part of the mutable vector without copying it.

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

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

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

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

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

unsafeSlice #

Arguments

:: Unbox 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 :: Unbox a => MVector s a -> MVector s a #

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

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

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

## Overlapping

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

Check whether two vectors overlap.

# Construction

## Initialisation

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

Create a mutable vector of the given length.

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

Create a mutable vector of the given length. The memory is not initialized.

replicate :: (PrimMonad m, Unbox 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, Unbox 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.

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

Create a copy of a mutable vector.

## Growing

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

Grow a vector by the given number of elements. The number must be positive.

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

Grow a vector by the given number of elements. The number must be positive but this is not checked.

## Restricting memory usage

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

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

# Zipping and unzipping

zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b) #

O(1) Zip 2 vectors

zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c) #

O(1) Zip 3 vectors

zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d) #

O(1) Zip 4 vectors

zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e) #

O(1) Zip 5 vectors

zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f) #

O(1) Zip 6 vectors

unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, MVector s b) #

O(1) Unzip 2 vectors

unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c) #

O(1) Unzip 3 vectors

unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s (a, b, c, d) -> (MVector s a, MVector s b, MVector s c, MVector s d) #

O(1) Unzip 4 vectors

unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e) #

O(1) Unzip 5 vectors

unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e, MVector s f) #

O(1) Unzip 6 vectors

# Accessing individual elements

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

Yield the element at the given position.

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

Replace the element at the given position.

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

Modify the element at the given position.

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

Swap the elements at the given positions.

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

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

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

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

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

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

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

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

# Modifying vectors

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

Compute the next (lexicographically) permutation of given vector in-place. Returns False when input is the last permtuation

## Filling and copying

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

Set all elements of the vector to the given value.

copy #

Arguments

:: (PrimMonad m, Unbox 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 :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> 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, Unbox 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. This is not checked.

unsafeMove #

Arguments

:: (PrimMonad m, Unbox 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.