Documentation

Methods

(==) :: SortTriple -> SortTriple -> Bool #

(/=) :: SortTriple -> SortTriple -> Bool #

Methods

compare :: SortTriple -> SortTriple -> Ordering #

(<) :: SortTriple -> SortTriple -> Bool #

(<=) :: SortTriple -> SortTriple -> Bool #

(>) :: SortTriple -> SortTriple -> Bool #

(>=) :: SortTriple -> SortTriple -> Bool #

max :: SortTriple -> SortTriple -> SortTriple #

min :: SortTriple -> SortTriple -> SortTriple #

Methods

sizeOfType# :: Proxy SortTriple -> Int# #

sizeOf# :: SortTriple -> Int# #

alignmentOfType# :: Proxy SortTriple -> Int# #

alignment# :: SortTriple -> Int# #

indexByteArray# :: ByteArray# -> Int# -> SortTriple #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, SortTriple #) #

writeByteArray# :: MutableByteArray# s -> Int# -> SortTriple -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> SortTriple -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> SortTriple #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, SortTriple #) #

writeOffAddr# :: Addr# -> Int# -> SortTriple -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> SortTriple -> State# s -> State# s #

Methods

basicUnsafeFreeze :: Mutable Vector s SortTriple -> ST s (Vector SortTriple)

basicUnsafeThaw :: Vector SortTriple -> ST s (Mutable Vector s SortTriple)

basicLength :: Vector SortTriple -> Int

basicUnsafeSlice :: Int -> Int -> Vector SortTriple -> Vector SortTriple

basicUnsafeIndexM :: Vector SortTriple -> Int -> Box SortTriple

basicUnsafeCopy :: Mutable Vector s SortTriple -> Vector SortTriple -> ST s ()

elemseq :: Vector SortTriple -> SortTriple -> b -> b

Methods

basicLength :: MVector s SortTriple -> Int

basicUnsafeSlice :: Int -> Int -> MVector s SortTriple -> MVector s SortTriple

basicOverlaps :: MVector s SortTriple -> MVector s SortTriple -> Bool

basicUnsafeNew :: Int -> ST s (MVector s SortTriple)

basicInitialize :: MVector s SortTriple -> ST s ()

basicUnsafeReplicate :: Int -> SortTriple -> ST s (MVector s SortTriple)

basicUnsafeRead :: MVector s SortTriple -> Int -> ST s SortTriple

basicUnsafeWrite :: MVector s SortTriple -> Int -> SortTriple -> ST s ()

basicClear :: MVector s SortTriple -> ST s ()

basicSet :: MVector s SortTriple -> SortTriple -> ST s ()

basicUnsafeCopy :: MVector s SortTriple -> MVector s SortTriple -> ST s ()

basicUnsafeMove :: MVector s SortTriple -> MVector s SortTriple -> ST s ()

basicUnsafeGrow :: MVector s SortTriple -> Int -> ST s (MVector s SortTriple)

Methods

toURepr :: SortTriple -> (Double, Double, Word64)

fromURepr :: (Double, Double, Word64) -> SortTriple

Methods

basicLength :: MVector s All -> Int

basicUnsafeSlice :: Int -> Int -> MVector s All -> MVector s All

basicOverlaps :: MVector s All -> MVector s All -> Bool

basicUnsafeNew :: Int -> ST s (MVector s All)

basicInitialize :: MVector s All -> ST s ()

basicUnsafeReplicate :: Int -> All -> ST s (MVector s All)

basicUnsafeRead :: MVector s All -> Int -> ST s All

basicUnsafeWrite :: MVector s All -> Int -> All -> ST s ()

basicClear :: MVector s All -> ST s ()

basicSet :: MVector s All -> All -> ST s ()

basicUnsafeCopy :: MVector s All -> MVector s All -> ST s ()

basicUnsafeMove :: MVector s All -> MVector s All -> ST s ()

basicUnsafeGrow :: MVector s All -> Int -> ST s (MVector s All)

Methods

basicLength :: MVector s Any -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Any -> MVector s Any

basicOverlaps :: MVector s Any -> MVector s Any -> Bool

basicUnsafeNew :: Int -> ST s (MVector s Any)

basicInitialize :: MVector s Any -> ST s ()

basicUnsafeReplicate :: Int -> Any -> ST s (MVector s Any)

basicUnsafeRead :: MVector s Any -> Int -> ST s Any

basicUnsafeWrite :: MVector s Any -> Int -> Any -> ST s ()

basicClear :: MVector s Any -> ST s ()

basicSet :: MVector s Any -> Any -> ST s ()

basicUnsafeCopy :: MVector s Any -> MVector s Any -> ST s ()

basicUnsafeMove :: MVector s Any -> MVector s Any -> ST s ()

basicUnsafeGrow :: MVector s Any -> Int -> ST s (MVector s Any)

Methods

basicLength :: MVector s Int16 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Int16)

basicInitialize :: MVector s Int16 -> ST s ()

basicUnsafeReplicate :: Int -> Int16 -> ST s (MVector s Int16)

basicUnsafeRead :: MVector s Int16 -> Int -> ST s Int16

basicUnsafeWrite :: MVector s Int16 -> Int -> Int16 -> ST s ()

basicClear :: MVector s Int16 -> ST s ()

basicSet :: MVector s Int16 -> Int16 -> ST s ()

basicUnsafeCopy :: MVector s Int16 -> MVector s Int16 -> ST s ()

basicUnsafeMove :: MVector s Int16 -> MVector s Int16 -> ST s ()

basicUnsafeGrow :: MVector s Int16 -> Int -> ST s (MVector s Int16)

Methods

basicLength :: MVector s Int32 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Int32)

basicInitialize :: MVector s Int32 -> ST s ()

basicUnsafeReplicate :: Int -> Int32 -> ST s (MVector s Int32)

basicUnsafeRead :: MVector s Int32 -> Int -> ST s Int32

basicUnsafeWrite :: MVector s Int32 -> Int -> Int32 -> ST s ()

basicClear :: MVector s Int32 -> ST s ()

basicSet :: MVector s Int32 -> Int32 -> ST s ()

basicUnsafeCopy :: MVector s Int32 -> MVector s Int32 -> ST s ()

basicUnsafeMove :: MVector s Int32 -> MVector s Int32 -> ST s ()

basicUnsafeGrow :: MVector s Int32 -> Int -> ST s (MVector s Int32)

Methods

basicLength :: MVector s Int64 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Int64)

basicInitialize :: MVector s Int64 -> ST s ()

basicUnsafeReplicate :: Int -> Int64 -> ST s (MVector s Int64)

basicUnsafeRead :: MVector s Int64 -> Int -> ST s Int64

basicUnsafeWrite :: MVector s Int64 -> Int -> Int64 -> ST s ()

basicClear :: MVector s Int64 -> ST s ()

basicSet :: MVector s Int64 -> Int64 -> ST s ()

basicUnsafeCopy :: MVector s Int64 -> MVector s Int64 -> ST s ()

basicUnsafeMove :: MVector s Int64 -> MVector s Int64 -> ST s ()

basicUnsafeGrow :: MVector s Int64 -> Int -> ST s (MVector s Int64)

Methods

basicLength :: MVector s Int8 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Int8)

basicInitialize :: MVector s Int8 -> ST s ()

basicUnsafeReplicate :: Int -> Int8 -> ST s (MVector s Int8)

basicUnsafeRead :: MVector s Int8 -> Int -> ST s Int8

basicUnsafeWrite :: MVector s Int8 -> Int -> Int8 -> ST s ()

basicClear :: MVector s Int8 -> ST s ()

basicSet :: MVector s Int8 -> Int8 -> ST s ()

basicUnsafeCopy :: MVector s Int8 -> MVector s Int8 -> ST s ()

basicUnsafeMove :: MVector s Int8 -> MVector s Int8 -> ST s ()

basicUnsafeGrow :: MVector s Int8 -> Int -> ST s (MVector s Int8)

Methods

basicLength :: MVector s Word16 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Word16)

basicInitialize :: MVector s Word16 -> ST s ()

basicUnsafeReplicate :: Int -> Word16 -> ST s (MVector s Word16)

basicUnsafeRead :: MVector s Word16 -> Int -> ST s Word16

basicUnsafeWrite :: MVector s Word16 -> Int -> Word16 -> ST s ()

basicClear :: MVector s Word16 -> ST s ()

basicSet :: MVector s Word16 -> Word16 -> ST s ()

basicUnsafeCopy :: MVector s Word16 -> MVector s Word16 -> ST s ()

basicUnsafeMove :: MVector s Word16 -> MVector s Word16 -> ST s ()

basicUnsafeGrow :: MVector s Word16 -> Int -> ST s (MVector s Word16)

Methods

basicLength :: MVector s Word32 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Word32)

basicInitialize :: MVector s Word32 -> ST s ()

basicUnsafeReplicate :: Int -> Word32 -> ST s (MVector s Word32)

basicUnsafeRead :: MVector s Word32 -> Int -> ST s Word32

basicUnsafeWrite :: MVector s Word32 -> Int -> Word32 -> ST s ()

basicClear :: MVector s Word32 -> ST s ()

basicSet :: MVector s Word32 -> Word32 -> ST s ()

basicUnsafeCopy :: MVector s Word32 -> MVector s Word32 -> ST s ()

basicUnsafeMove :: MVector s Word32 -> MVector s Word32 -> ST s ()

basicUnsafeGrow :: MVector s Word32 -> Int -> ST s (MVector s Word32)

Methods

basicLength :: MVector s Word64 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Word64)

basicInitialize :: MVector s Word64 -> ST s ()

basicUnsafeReplicate :: Int -> Word64 -> ST s (MVector s Word64)

basicUnsafeRead :: MVector s Word64 -> Int -> ST s Word64

basicUnsafeWrite :: MVector s Word64 -> Int -> Word64 -> ST s ()

basicClear :: MVector s Word64 -> ST s ()

basicSet :: MVector s Word64 -> Word64 -> ST s ()

basicUnsafeCopy :: MVector s Word64 -> MVector s Word64 -> ST s ()

basicUnsafeMove :: MVector s Word64 -> MVector s Word64 -> ST s ()

basicUnsafeGrow :: MVector s Word64 -> Int -> ST s (MVector s Word64)

Methods

basicLength :: MVector s Word8 -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Word8)

basicInitialize :: MVector s Word8 -> ST s ()

basicUnsafeReplicate :: Int -> Word8 -> ST s (MVector s Word8)

basicUnsafeRead :: MVector s Word8 -> Int -> ST s Word8

basicUnsafeWrite :: MVector s Word8 -> Int -> Word8 -> ST s ()

basicClear :: MVector s Word8 -> ST s ()

basicSet :: MVector s Word8 -> Word8 -> ST s ()

basicUnsafeCopy :: MVector s Word8 -> MVector s Word8 -> ST s ()

basicUnsafeMove :: MVector s Word8 -> MVector s Word8 -> ST s ()

basicUnsafeGrow :: MVector s Word8 -> Int -> ST s (MVector s Word8)

Methods

basicLength :: MVector s SortTriple -> Int

basicUnsafeSlice :: Int -> Int -> MVector s SortTriple -> MVector s SortTriple

basicOverlaps :: MVector s SortTriple -> MVector s SortTriple -> Bool

basicUnsafeNew :: Int -> ST s (MVector s SortTriple)

basicInitialize :: MVector s SortTriple -> ST s ()

basicUnsafeReplicate :: Int -> SortTriple -> ST s (MVector s SortTriple)

basicUnsafeRead :: MVector s SortTriple -> Int -> ST s SortTriple

basicUnsafeWrite :: MVector s SortTriple -> Int -> SortTriple -> ST s ()

basicClear :: MVector s SortTriple -> ST s ()

basicSet :: MVector s SortTriple -> SortTriple -> ST s ()

basicUnsafeCopy :: MVector s SortTriple -> MVector s SortTriple -> ST s ()

basicUnsafeMove :: MVector s SortTriple -> MVector s SortTriple -> ST s ()

basicUnsafeGrow :: MVector s SortTriple -> Int -> ST s (MVector s SortTriple)

Methods

basicLength :: MVector s () -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s ())

basicInitialize :: MVector s () -> ST s ()

basicUnsafeReplicate :: Int -> () -> ST s (MVector s ())

basicUnsafeRead :: MVector s () -> Int -> ST s ()

basicUnsafeWrite :: MVector s () -> Int -> () -> ST s ()

basicClear :: MVector s () -> ST s ()

basicSet :: MVector s () -> () -> ST s ()

basicUnsafeCopy :: MVector s () -> MVector s () -> ST s ()

basicUnsafeMove :: MVector s () -> MVector s () -> ST s ()

basicUnsafeGrow :: MVector s () -> Int -> ST s (MVector s ())

Methods

basicLength :: MVector s Bool -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Bool)

basicInitialize :: MVector s Bool -> ST s ()

basicUnsafeReplicate :: Int -> Bool -> ST s (MVector s Bool)

basicUnsafeRead :: MVector s Bool -> Int -> ST s Bool

basicUnsafeWrite :: MVector s Bool -> Int -> Bool -> ST s ()

basicClear :: MVector s Bool -> ST s ()

basicSet :: MVector s Bool -> Bool -> ST s ()

basicUnsafeCopy :: MVector s Bool -> MVector s Bool -> ST s ()

basicUnsafeMove :: MVector s Bool -> MVector s Bool -> ST s ()

basicUnsafeGrow :: MVector s Bool -> Int -> ST s (MVector s Bool)

Methods

basicLength :: MVector s Char -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Char)

basicInitialize :: MVector s Char -> ST s ()

basicUnsafeReplicate :: Int -> Char -> ST s (MVector s Char)

basicUnsafeRead :: MVector s Char -> Int -> ST s Char

basicUnsafeWrite :: MVector s Char -> Int -> Char -> ST s ()

basicClear :: MVector s Char -> ST s ()

basicSet :: MVector s Char -> Char -> ST s ()

basicUnsafeCopy :: MVector s Char -> MVector s Char -> ST s ()

basicUnsafeMove :: MVector s Char -> MVector s Char -> ST s ()

basicUnsafeGrow :: MVector s Char -> Int -> ST s (MVector s Char)

Methods

basicLength :: MVector s Double -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Double)

basicInitialize :: MVector s Double -> ST s ()

basicUnsafeReplicate :: Int -> Double -> ST s (MVector s Double)

basicUnsafeRead :: MVector s Double -> Int -> ST s Double

basicUnsafeWrite :: MVector s Double -> Int -> Double -> ST s ()

basicClear :: MVector s Double -> ST s ()

basicSet :: MVector s Double -> Double -> ST s ()

basicUnsafeCopy :: MVector s Double -> MVector s Double -> ST s ()

basicUnsafeMove :: MVector s Double -> MVector s Double -> ST s ()

basicUnsafeGrow :: MVector s Double -> Int -> ST s (MVector s Double)

Methods

basicLength :: MVector s Float -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Float)

basicInitialize :: MVector s Float -> ST s ()

basicUnsafeReplicate :: Int -> Float -> ST s (MVector s Float)

basicUnsafeRead :: MVector s Float -> Int -> ST s Float

basicUnsafeWrite :: MVector s Float -> Int -> Float -> ST s ()

basicClear :: MVector s Float -> ST s ()

basicSet :: MVector s Float -> Float -> ST s ()

basicUnsafeCopy :: MVector s Float -> MVector s Float -> ST s ()

basicUnsafeMove :: MVector s Float -> MVector s Float -> ST s ()

basicUnsafeGrow :: MVector s Float -> Int -> ST s (MVector s Float)

Methods

basicLength :: MVector s Int -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Int)

basicInitialize :: MVector s Int -> ST s ()

basicUnsafeReplicate :: Int -> Int -> ST s (MVector s Int)

basicUnsafeRead :: MVector s Int -> Int -> ST s Int

basicUnsafeWrite :: MVector s Int -> Int -> Int -> ST s ()

basicClear :: MVector s Int -> ST s ()

basicSet :: MVector s Int -> Int -> ST s ()

basicUnsafeCopy :: MVector s Int -> MVector s Int -> ST s ()

basicUnsafeMove :: MVector s Int -> MVector s Int -> ST s ()

basicUnsafeGrow :: MVector s Int -> Int -> ST s (MVector s Int)

Methods

basicLength :: MVector s Word -> Int

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

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

basicUnsafeNew :: Int -> ST s (MVector s Word)

basicInitialize :: MVector s Word -> ST s ()

basicUnsafeReplicate :: Int -> Word -> ST s (MVector s Word)

basicUnsafeRead :: MVector s Word -> Int -> ST s Word

basicUnsafeWrite :: MVector s Word -> Int -> Word -> ST s ()

basicClear :: MVector s Word -> ST s ()

basicSet :: MVector s Word -> Word -> ST s ()

basicUnsafeCopy :: MVector s Word -> MVector s Word -> ST s ()

basicUnsafeMove :: MVector s Word -> MVector s Word -> ST s ()

basicUnsafeGrow :: MVector s Word -> Int -> ST s (MVector s Word)

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 :: Int -> ST s (MVector s (Complex a))

basicInitialize :: MVector s (Complex a) -> ST s ()

basicUnsafeReplicate :: Int -> Complex a -> ST s (MVector s (Complex a))

basicUnsafeRead :: MVector s (Complex a) -> Int -> ST s (Complex a)

basicUnsafeWrite :: MVector s (Complex a) -> Int -> Complex a -> ST s ()

basicClear :: MVector s (Complex a) -> ST s ()

basicSet :: MVector s (Complex a) -> Complex a -> ST s ()

basicUnsafeCopy :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeMove :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeGrow :: MVector s (Complex a) -> Int -> ST s (MVector s (Complex a))

Methods

basicLength :: MVector s (Identity a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Identity a) -> MVector s (Identity a)

basicOverlaps :: MVector s (Identity a) -> MVector s (Identity a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Identity a))

basicInitialize :: MVector s (Identity a) -> ST s ()

basicUnsafeReplicate :: Int -> Identity a -> ST s (MVector s (Identity a))

basicUnsafeRead :: MVector s (Identity a) -> Int -> ST s (Identity a)

basicUnsafeWrite :: MVector s (Identity a) -> Int -> Identity a -> ST s ()

basicClear :: MVector s (Identity a) -> ST s ()

basicSet :: MVector s (Identity a) -> Identity a -> ST s ()

basicUnsafeCopy :: MVector s (Identity a) -> MVector s (Identity a) -> ST s ()

basicUnsafeMove :: MVector s (Identity a) -> MVector s (Identity a) -> ST s ()

basicUnsafeGrow :: MVector s (Identity a) -> Int -> ST s (MVector s (Identity a))

Methods

basicLength :: MVector s (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Down a) -> MVector s (Down a)

basicOverlaps :: MVector s (Down a) -> MVector s (Down a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Down a))

basicInitialize :: MVector s (Down a) -> ST s ()

basicUnsafeReplicate :: Int -> Down a -> ST s (MVector s (Down a))

basicUnsafeRead :: MVector s (Down a) -> Int -> ST s (Down a)

basicUnsafeWrite :: MVector s (Down a) -> Int -> Down a -> ST s ()

basicClear :: MVector s (Down a) -> ST s ()

basicSet :: MVector s (Down a) -> Down a -> ST s ()

basicUnsafeCopy :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeMove :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeGrow :: MVector s (Down a) -> Int -> ST s (MVector s (Down a))

Methods

basicLength :: MVector s (First a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (First a) -> MVector s (First a)

basicOverlaps :: MVector s (First a) -> MVector s (First a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (First a))

basicInitialize :: MVector s (First a) -> ST s ()

basicUnsafeReplicate :: Int -> First a -> ST s (MVector s (First a))

basicUnsafeRead :: MVector s (First a) -> Int -> ST s (First a)

basicUnsafeWrite :: MVector s (First a) -> Int -> First a -> ST s ()

basicClear :: MVector s (First a) -> ST s ()

basicSet :: MVector s (First a) -> First a -> ST s ()

basicUnsafeCopy :: MVector s (First a) -> MVector s (First a) -> ST s ()

basicUnsafeMove :: MVector s (First a) -> MVector s (First a) -> ST s ()

basicUnsafeGrow :: MVector s (First a) -> Int -> ST s (MVector s (First a))

Methods

basicLength :: MVector s (Last a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Last a) -> MVector s (Last a)

basicOverlaps :: MVector s (Last a) -> MVector s (Last a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Last a))

basicInitialize :: MVector s (Last a) -> ST s ()

basicUnsafeReplicate :: Int -> Last a -> ST s (MVector s (Last a))

basicUnsafeRead :: MVector s (Last a) -> Int -> ST s (Last a)

basicUnsafeWrite :: MVector s (Last a) -> Int -> Last a -> ST s ()

basicClear :: MVector s (Last a) -> ST s ()

basicSet :: MVector s (Last a) -> Last a -> ST s ()

basicUnsafeCopy :: MVector s (Last a) -> MVector s (Last a) -> ST s ()

basicUnsafeMove :: MVector s (Last a) -> MVector s (Last a) -> ST s ()

basicUnsafeGrow :: MVector s (Last a) -> Int -> ST s (MVector s (Last a))

Methods

basicLength :: MVector s (Max a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Max a) -> MVector s (Max a)

basicOverlaps :: MVector s (Max a) -> MVector s (Max a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Max a))

basicInitialize :: MVector s (Max a) -> ST s ()

basicUnsafeReplicate :: Int -> Max a -> ST s (MVector s (Max a))

basicUnsafeRead :: MVector s (Max a) -> Int -> ST s (Max a)

basicUnsafeWrite :: MVector s (Max a) -> Int -> Max a -> ST s ()

basicClear :: MVector s (Max a) -> ST s ()

basicSet :: MVector s (Max a) -> Max a -> ST s ()

basicUnsafeCopy :: MVector s (Max a) -> MVector s (Max a) -> ST s ()

basicUnsafeMove :: MVector s (Max a) -> MVector s (Max a) -> ST s ()

basicUnsafeGrow :: MVector s (Max a) -> Int -> ST s (MVector s (Max a))

Methods

basicLength :: MVector s (Min a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Min a) -> MVector s (Min a)

basicOverlaps :: MVector s (Min a) -> MVector s (Min a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Min a))

basicInitialize :: MVector s (Min a) -> ST s ()

basicUnsafeReplicate :: Int -> Min a -> ST s (MVector s (Min a))

basicUnsafeRead :: MVector s (Min a) -> Int -> ST s (Min a)

basicUnsafeWrite :: MVector s (Min a) -> Int -> Min a -> ST s ()

basicClear :: MVector s (Min a) -> ST s ()

basicSet :: MVector s (Min a) -> Min a -> ST s ()

basicUnsafeCopy :: MVector s (Min a) -> MVector s (Min a) -> ST s ()

basicUnsafeMove :: MVector s (Min a) -> MVector s (Min a) -> ST s ()

basicUnsafeGrow :: MVector s (Min a) -> Int -> ST s (MVector s (Min a))

Methods

basicLength :: MVector s (WrappedMonoid a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a)

basicOverlaps :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (WrappedMonoid a))

basicInitialize :: MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeReplicate :: Int -> WrappedMonoid a -> ST s (MVector s (WrappedMonoid a))

basicUnsafeRead :: MVector s (WrappedMonoid a) -> Int -> ST s (WrappedMonoid a)

basicUnsafeWrite :: MVector s (WrappedMonoid a) -> Int -> WrappedMonoid a -> ST s ()

basicClear :: MVector s (WrappedMonoid a) -> ST s ()

basicSet :: MVector s (WrappedMonoid a) -> WrappedMonoid a -> ST s ()

basicUnsafeCopy :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeMove :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s ()

basicUnsafeGrow :: MVector s (WrappedMonoid a) -> Int -> ST s (MVector s (WrappedMonoid a))

Methods

basicLength :: MVector s (Dual a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Dual a) -> MVector s (Dual a)

basicOverlaps :: MVector s (Dual a) -> MVector s (Dual a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Dual a))

basicInitialize :: MVector s (Dual a) -> ST s ()

basicUnsafeReplicate :: Int -> Dual a -> ST s (MVector s (Dual a))

basicUnsafeRead :: MVector s (Dual a) -> Int -> ST s (Dual a)

basicUnsafeWrite :: MVector s (Dual a) -> Int -> Dual a -> ST s ()

basicClear :: MVector s (Dual a) -> ST s ()

basicSet :: MVector s (Dual a) -> Dual a -> ST s ()

basicUnsafeCopy :: MVector s (Dual a) -> MVector s (Dual a) -> ST s ()

basicUnsafeMove :: MVector s (Dual a) -> MVector s (Dual a) -> ST s ()

basicUnsafeGrow :: MVector s (Dual a) -> Int -> ST s (MVector s (Dual a))

Methods

basicLength :: MVector s (Product a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Product a) -> MVector s (Product a)

basicOverlaps :: MVector s (Product a) -> MVector s (Product a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Product a))

basicInitialize :: MVector s (Product a) -> ST s ()

basicUnsafeReplicate :: Int -> Product a -> ST s (MVector s (Product a))

basicUnsafeRead :: MVector s (Product a) -> Int -> ST s (Product a)

basicUnsafeWrite :: MVector s (Product a) -> Int -> Product a -> ST s ()

basicClear :: MVector s (Product a) -> ST s ()

basicSet :: MVector s (Product a) -> Product a -> ST s ()

basicUnsafeCopy :: MVector s (Product a) -> MVector s (Product a) -> ST s ()

basicUnsafeMove :: MVector s (Product a) -> MVector s (Product a) -> ST s ()

basicUnsafeGrow :: MVector s (Product a) -> Int -> ST s (MVector s (Product a))

Methods

basicLength :: MVector s (Sum a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Sum a) -> MVector s (Sum a)

basicOverlaps :: MVector s (Sum a) -> MVector s (Sum a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Sum a))

basicInitialize :: MVector s (Sum a) -> ST s ()

basicUnsafeReplicate :: Int -> Sum a -> ST s (MVector s (Sum a))

basicUnsafeRead :: MVector s (Sum a) -> Int -> ST s (Sum a)

basicUnsafeWrite :: MVector s (Sum a) -> Int -> Sum a -> ST s ()

basicClear :: MVector s (Sum a) -> ST s ()

basicSet :: MVector s (Sum a) -> Sum a -> ST s ()

basicUnsafeCopy :: MVector s (Sum a) -> MVector s (Sum a) -> ST s ()

basicUnsafeMove :: MVector s (Sum a) -> MVector s (Sum a) -> ST s ()

basicUnsafeGrow :: MVector s (Sum a) -> Int -> ST s (MVector s (Sum a))

Methods

basicLength :: MVector s (DoNotUnboxLazy a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a)

basicOverlaps :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxLazy a))

basicInitialize :: MVector s (DoNotUnboxLazy a) -> ST s ()

basicUnsafeReplicate :: Int -> DoNotUnboxLazy a -> ST s (MVector s (DoNotUnboxLazy a))

basicUnsafeRead :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (DoNotUnboxLazy a)

basicUnsafeWrite :: MVector s (DoNotUnboxLazy a) -> Int -> DoNotUnboxLazy a -> ST s ()

basicClear :: MVector s (DoNotUnboxLazy a) -> ST s ()

basicSet :: MVector s (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> ST s ()

basicUnsafeCopy :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s ()

basicUnsafeMove :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s ()

basicUnsafeGrow :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (MVector s (DoNotUnboxLazy a))

Methods

basicLength :: MVector s (DoNotUnboxNormalForm a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a)

basicOverlaps :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxNormalForm a))

basicInitialize :: MVector s (DoNotUnboxNormalForm a) -> ST s ()

basicUnsafeReplicate :: Int -> DoNotUnboxNormalForm a -> ST s (MVector s (DoNotUnboxNormalForm a))

basicUnsafeRead :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (DoNotUnboxNormalForm a)

basicUnsafeWrite :: MVector s (DoNotUnboxNormalForm a) -> Int -> DoNotUnboxNormalForm a -> ST s ()

basicClear :: MVector s (DoNotUnboxNormalForm a) -> ST s ()

basicSet :: MVector s (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> ST s ()

basicUnsafeCopy :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s ()

basicUnsafeMove :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s ()

basicUnsafeGrow :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (MVector s (DoNotUnboxNormalForm a))

Methods

basicLength :: MVector s (DoNotUnboxStrict a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a)

basicOverlaps :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxStrict a))

basicInitialize :: MVector s (DoNotUnboxStrict a) -> ST s ()

basicUnsafeReplicate :: Int -> DoNotUnboxStrict a -> ST s (MVector s (DoNotUnboxStrict a))

basicUnsafeRead :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (DoNotUnboxStrict a)

basicUnsafeWrite :: MVector s (DoNotUnboxStrict a) -> Int -> DoNotUnboxStrict a -> ST s ()

basicClear :: MVector s (DoNotUnboxStrict a) -> ST s ()

basicSet :: MVector s (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> ST s ()

basicUnsafeCopy :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s ()

basicUnsafeMove :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s ()

basicUnsafeGrow :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (MVector s (DoNotUnboxStrict a))

Methods

basicLength :: MVector s (UnboxViaPrim a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a)

basicOverlaps :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (UnboxViaPrim a))

basicInitialize :: MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeReplicate :: Int -> UnboxViaPrim a -> ST s (MVector s (UnboxViaPrim a))

basicUnsafeRead :: MVector s (UnboxViaPrim a) -> Int -> ST s (UnboxViaPrim a)

basicUnsafeWrite :: MVector s (UnboxViaPrim a) -> Int -> UnboxViaPrim a -> ST s ()

basicClear :: MVector s (UnboxViaPrim a) -> ST s ()

basicSet :: MVector s (UnboxViaPrim a) -> UnboxViaPrim a -> ST s ()

basicUnsafeCopy :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeMove :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s ()

basicUnsafeGrow :: MVector s (UnboxViaPrim a) -> Int -> ST s (MVector s (UnboxViaPrim a))

Methods

basicLength :: MVector s (Arg a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Arg a b) -> MVector s (Arg a b)

basicOverlaps :: MVector s (Arg a b) -> MVector s (Arg a b) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Arg a b))

basicInitialize :: MVector s (Arg a b) -> ST s ()

basicUnsafeReplicate :: Int -> Arg a b -> ST s (MVector s (Arg a b))

basicUnsafeRead :: MVector s (Arg a b) -> Int -> ST s (Arg a b)

basicUnsafeWrite :: MVector s (Arg a b) -> Int -> Arg a b -> ST s ()

basicClear :: MVector s (Arg a b) -> ST s ()

basicSet :: MVector s (Arg a b) -> Arg a b -> ST s ()

basicUnsafeCopy :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s ()

basicUnsafeMove :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s ()

basicUnsafeGrow :: MVector s (Arg a b) -> Int -> ST s (MVector s (Arg a b))

Methods

basicLength :: MVector s (As a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (As a b) -> MVector s (As a b)

basicOverlaps :: MVector s (As a b) -> MVector s (As a b) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (As a b))

basicInitialize :: MVector s (As a b) -> ST s ()

basicUnsafeReplicate :: Int -> As a b -> ST s (MVector s (As a b))

basicUnsafeRead :: MVector s (As a b) -> Int -> ST s (As a b)

basicUnsafeWrite :: MVector s (As a b) -> Int -> As a b -> ST s ()

basicClear :: MVector s (As a b) -> ST s ()

basicSet :: MVector s (As a b) -> As a b -> ST s ()

basicUnsafeCopy :: MVector s (As a b) -> MVector s (As a b) -> ST s ()

basicUnsafeMove :: MVector s (As a b) -> MVector s (As a b) -> ST s ()

basicUnsafeGrow :: MVector s (As a b) -> Int -> ST s (MVector s (As a b))

Methods

basicLength :: MVector s (TestPair a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (TestPair a b) -> MVector s (TestPair a b)

basicOverlaps :: MVector s (TestPair a b) -> MVector s (TestPair a b) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (TestPair a b))

basicInitialize :: MVector s (TestPair a b) -> ST s ()

basicUnsafeReplicate :: Int -> TestPair a b -> ST s (MVector s (TestPair a b))

basicUnsafeRead :: MVector s (TestPair a b) -> Int -> ST s (TestPair a b)

basicUnsafeWrite :: MVector s (TestPair a b) -> Int -> TestPair a b -> ST s ()

basicClear :: MVector s (TestPair a b) -> ST s ()

basicSet :: MVector s (TestPair a b) -> TestPair a b -> ST s ()

basicUnsafeCopy :: MVector s (TestPair a b) -> MVector s (TestPair a b) -> ST s ()

basicUnsafeMove :: MVector s (TestPair a b) -> MVector s (TestPair a b) -> ST s ()

basicUnsafeGrow :: MVector s (TestPair a b) -> Int -> ST s (MVector s (TestPair a b))

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 :: Int -> ST s (MVector s (a, b))

basicInitialize :: MVector s (a, b) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b) -> ST s (MVector s (a, b))

basicUnsafeRead :: MVector s (a, b) -> Int -> ST s (a, b)

basicUnsafeWrite :: MVector s (a, b) -> Int -> (a, b) -> ST s ()

basicClear :: MVector s (a, b) -> ST s ()

basicSet :: MVector s (a, b) -> (a, b) -> ST s ()

basicUnsafeCopy :: MVector s (a, b) -> MVector s (a, b) -> ST s ()

basicUnsafeMove :: MVector s (a, b) -> MVector s (a, b) -> ST s ()

basicUnsafeGrow :: MVector s (a, b) -> Int -> ST s (MVector s (a, b))

Methods

basicLength :: MVector s (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b)

basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Const a b))

basicInitialize :: MVector s (Const a b) -> ST s ()

basicUnsafeReplicate :: Int -> Const a b -> ST s (MVector s (Const a b))

basicUnsafeRead :: MVector s (Const a b) -> Int -> ST s (Const a b)

basicUnsafeWrite :: MVector s (Const a b) -> Int -> Const a b -> ST s ()

basicClear :: MVector s (Const a b) -> ST s ()

basicSet :: MVector s (Const a b) -> Const a b -> ST s ()

basicUnsafeCopy :: MVector s (Const a b) -> MVector s (Const a b) -> ST s ()

basicUnsafeMove :: MVector s (Const a b) -> MVector s (Const a b) -> ST s ()

basicUnsafeGrow :: MVector s (Const a b) -> Int -> ST s (MVector s (Const a b))

Methods

basicLength :: MVector s (Alt f a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Alt f a) -> MVector s (Alt f a)

basicOverlaps :: MVector s (Alt f a) -> MVector s (Alt f a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Alt f a))

basicInitialize :: MVector s (Alt f a) -> ST s ()

basicUnsafeReplicate :: Int -> Alt f a -> ST s (MVector s (Alt f a))

basicUnsafeRead :: MVector s (Alt f a) -> Int -> ST s (Alt f a)

basicUnsafeWrite :: MVector s (Alt f a) -> Int -> Alt f a -> ST s ()

basicClear :: MVector s (Alt f a) -> ST s ()

basicSet :: MVector s (Alt f a) -> Alt f a -> ST s ()

basicUnsafeCopy :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s ()

basicUnsafeMove :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s ()

basicUnsafeGrow :: MVector s (Alt f a) -> Int -> ST s (MVector s (Alt f a))

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 :: Int -> ST s (MVector s (a, b, c))

basicInitialize :: MVector s (a, b, c) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b, c) -> ST s (MVector s (a, b, c))

basicUnsafeRead :: MVector s (a, b, c) -> Int -> ST s (a, b, c)

basicUnsafeWrite :: MVector s (a, b, c) -> Int -> (a, b, c) -> ST s ()

basicClear :: MVector s (a, b, c) -> ST s ()

basicSet :: MVector s (a, b, c) -> (a, b, c) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s ()

basicUnsafeGrow :: MVector s (a, b, c) -> Int -> ST s (MVector s (a, b, c))

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 :: Int -> ST s (MVector s (a, b, c, d))

basicInitialize :: MVector s (a, b, c, d) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b, c, d) -> ST s (MVector s (a, b, c, d))

basicUnsafeRead :: MVector s (a, b, c, d) -> Int -> ST s (a, b, c, d)

basicUnsafeWrite :: MVector s (a, b, c, d) -> Int -> (a, b, c, d) -> ST s ()

basicClear :: MVector s (a, b, c, d) -> ST s ()

basicSet :: MVector s (a, b, c, d) -> (a, b, c, d) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s ()

basicUnsafeGrow :: MVector s (a, b, c, d) -> Int -> ST s (MVector s (a, b, c, d))

Methods

basicLength :: MVector s (Compose f g a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Compose f g a) -> MVector s (Compose f g a)

basicOverlaps :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Compose f g a))

basicInitialize :: MVector s (Compose f g a) -> ST s ()

basicUnsafeReplicate :: Int -> Compose f g a -> ST s (MVector s (Compose f g a))

basicUnsafeRead :: MVector s (Compose f g a) -> Int -> ST s (Compose f g a)

basicUnsafeWrite :: MVector s (Compose f g a) -> Int -> Compose f g a -> ST s ()

basicClear :: MVector s (Compose f g a) -> ST s ()

basicSet :: MVector s (Compose f g a) -> Compose f g a -> ST s ()

basicUnsafeCopy :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s ()

basicUnsafeMove :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s ()

basicUnsafeGrow :: MVector s (Compose f g a) -> Int -> ST s (MVector s (Compose f g a))

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 :: Int -> ST s (MVector s (a, b, c, d, e))

basicInitialize :: MVector s (a, b, c, d, e) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b, c, d, e) -> ST s (MVector s (a, b, c, d, e))

basicUnsafeRead :: MVector s (a, b, c, d, e) -> Int -> ST s (a, b, c, d, e)

basicUnsafeWrite :: MVector s (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> ST s ()

basicClear :: MVector s (a, b, c, d, e) -> ST s ()

basicSet :: MVector s (a, b, c, d, e) -> (a, b, c, d, e) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s ()

basicUnsafeGrow :: MVector s (a, b, c, d, e) -> Int -> ST s (MVector s (a, b, c, d, e))

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 :: Int -> ST s (MVector s (a, b, c, d, e, f))

basicInitialize :: MVector s (a, b, c, d, e, f) -> ST s ()

basicUnsafeReplicate :: Int -> (a, b, c, d, e, f) -> ST s (MVector s (a, b, c, d, e, f))

basicUnsafeRead :: MVector s (a, b, c, d, e, f) -> Int -> ST s (a, b, c, d, e, f)

basicUnsafeWrite :: MVector s (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> ST s ()

basicClear :: MVector s (a, b, c, d, e, f) -> ST s ()

basicSet :: MVector s (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> ST s ()

basicUnsafeCopy :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s ()

basicUnsafeMove :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s ()

basicUnsafeGrow :: MVector s (a, b, c, d, e, f) -> Int -> ST s (MVector s (a, b, c, d, e, f))

Methods

liftRnf :: (a -> ()) -> MVector s a -> () #

Methods

rnf :: MVector s a -> () #

Methods

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

Methods

basicUnsafeFreeze :: Mutable Vector s All -> ST s (Vector All)

basicUnsafeThaw :: Vector All -> ST s (Mutable Vector s All)

basicLength :: Vector All -> Int

basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All

basicUnsafeIndexM :: Vector All -> Int -> Box All

basicUnsafeCopy :: Mutable Vector s All -> Vector All -> ST s ()

elemseq :: Vector All -> All -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Any -> ST s (Vector Any)

basicUnsafeThaw :: Vector Any -> ST s (Mutable Vector s Any)

basicLength :: Vector Any -> Int

basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any

basicUnsafeIndexM :: Vector Any -> Int -> Box Any

basicUnsafeCopy :: Mutable Vector s Any -> Vector Any -> ST s ()

elemseq :: Vector Any -> Any -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Int16 -> ST s (Vector Int16)

basicUnsafeThaw :: Vector Int16 -> ST s (Mutable Vector s Int16)

basicLength :: Vector Int16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16

basicUnsafeIndexM :: Vector Int16 -> Int -> Box Int16

basicUnsafeCopy :: Mutable Vector s Int16 -> Vector Int16 -> ST s ()

elemseq :: Vector Int16 -> Int16 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Int32 -> ST s (Vector Int32)

basicUnsafeThaw :: Vector Int32 -> ST s (Mutable Vector s Int32)

basicLength :: Vector Int32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32

basicUnsafeIndexM :: Vector Int32 -> Int -> Box Int32

basicUnsafeCopy :: Mutable Vector s Int32 -> Vector Int32 -> ST s ()

elemseq :: Vector Int32 -> Int32 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Int64 -> ST s (Vector Int64)

basicUnsafeThaw :: Vector Int64 -> ST s (Mutable Vector s Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Vector Int64 -> Int -> Box Int64

basicUnsafeCopy :: Mutable Vector s Int64 -> Vector Int64 -> ST s ()

elemseq :: Vector Int64 -> Int64 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Int8 -> ST s (Vector Int8)

basicUnsafeThaw :: Vector Int8 -> ST s (Mutable Vector s Int8)

basicLength :: Vector Int8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8

basicUnsafeIndexM :: Vector Int8 -> Int -> Box Int8

basicUnsafeCopy :: Mutable Vector s Int8 -> Vector Int8 -> ST s ()

elemseq :: Vector Int8 -> Int8 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Word16 -> ST s (Vector Word16)

basicUnsafeThaw :: Vector Word16 -> ST s (Mutable Vector s Word16)

basicLength :: Vector Word16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16

basicUnsafeIndexM :: Vector Word16 -> Int -> Box Word16

basicUnsafeCopy :: Mutable Vector s Word16 -> Vector Word16 -> ST s ()

elemseq :: Vector Word16 -> Word16 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Word32 -> ST s (Vector Word32)

basicUnsafeThaw :: Vector Word32 -> ST s (Mutable Vector s Word32)

basicLength :: Vector Word32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32

basicUnsafeIndexM :: Vector Word32 -> Int -> Box Word32

basicUnsafeCopy :: Mutable Vector s Word32 -> Vector Word32 -> ST s ()

elemseq :: Vector Word32 -> Word32 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Word64 -> ST s (Vector Word64)

basicUnsafeThaw :: Vector Word64 -> ST s (Mutable Vector s Word64)

basicLength :: Vector Word64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64

basicUnsafeIndexM :: Vector Word64 -> Int -> Box Word64

basicUnsafeCopy :: Mutable Vector s Word64 -> Vector Word64 -> ST s ()

elemseq :: Vector Word64 -> Word64 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Word8 -> ST s (Vector Word8)

basicUnsafeThaw :: Vector Word8 -> ST s (Mutable Vector s Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Vector Word8 -> Int -> Box Word8

basicUnsafeCopy :: Mutable Vector s Word8 -> Vector Word8 -> ST s ()

elemseq :: Vector Word8 -> Word8 -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s SortTriple -> ST s (Vector SortTriple)

basicUnsafeThaw :: Vector SortTriple -> ST s (Mutable Vector s SortTriple)

basicLength :: Vector SortTriple -> Int

basicUnsafeSlice :: Int -> Int -> Vector SortTriple -> Vector SortTriple

basicUnsafeIndexM :: Vector SortTriple -> Int -> Box SortTriple

basicUnsafeCopy :: Mutable Vector s SortTriple -> Vector SortTriple -> ST s ()

elemseq :: Vector SortTriple -> SortTriple -> b -> b

Methods

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

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

basicLength :: Vector () -> Int

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()

basicUnsafeIndexM :: Vector () -> Int -> Box ()

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

elemseq :: Vector () -> () -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Bool -> ST s (Vector Bool)

basicUnsafeThaw :: Vector Bool -> ST s (Mutable Vector s Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Vector Bool -> Int -> Box Bool

basicUnsafeCopy :: Mutable Vector s Bool -> Vector Bool -> ST s ()

elemseq :: Vector Bool -> Bool -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Char -> ST s (Vector Char)

basicUnsafeThaw :: Vector Char -> ST s (Mutable Vector s Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Vector Char -> Int -> Box Char

basicUnsafeCopy :: Mutable Vector s Char -> Vector Char -> ST s ()

elemseq :: Vector Char -> Char -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Double -> ST s (Vector Double)

basicUnsafeThaw :: Vector Double -> ST s (Mutable Vector s Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Vector Double -> Int -> Box Double

basicUnsafeCopy :: Mutable Vector s Double -> Vector Double -> ST s ()

elemseq :: Vector Double -> Double -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float)

basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Vector Float -> Int -> Box Float

basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s ()

elemseq :: Vector Float -> Float -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int)

basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Vector Int -> Int -> Box Int

basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s ()

elemseq :: Vector Int -> Int -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word)

basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Vector Word -> Int -> Box Word

basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s ()

elemseq :: Vector Word -> Word -> b -> b

Methods

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

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

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Vector (Complex a) -> Int -> Box (Complex a)

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

elemseq :: Vector (Complex a) -> Complex a -> b -> b

Methods

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

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

basicLength :: Vector (Identity a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a)

basicUnsafeIndexM :: Vector (Identity a) -> Int -> Box (Identity a)

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

elemseq :: Vector (Identity a) -> Identity a -> b -> b

Methods

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

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

basicLength :: Vector (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a)

basicUnsafeIndexM :: Vector (Down a) -> Int -> Box (Down a)

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

elemseq :: Vector (Down a) -> Down a -> b -> b

Methods

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

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

basicLength :: Vector (First a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a)

basicUnsafeIndexM :: Vector (First a) -> Int -> Box (First a)

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

elemseq :: Vector (First a) -> First a -> b -> b

Methods

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

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

basicLength :: Vector (Last a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a)

basicUnsafeIndexM :: Vector (Last a) -> Int -> Box (Last a)

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

elemseq :: Vector (Last a) -> Last a -> b -> b

Methods

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

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

basicLength :: Vector (Max a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a)

basicUnsafeIndexM :: Vector (Max a) -> Int -> Box (Max a)

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

elemseq :: Vector (Max a) -> Max a -> b -> b

Methods

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

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

basicLength :: Vector (Min a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a)

basicUnsafeIndexM :: Vector (Min a) -> Int -> Box (Min a)

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

elemseq :: Vector (Min a) -> Min a -> b -> b

Methods

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

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

basicLength :: Vector (WrappedMonoid a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a)

basicUnsafeIndexM :: Vector (WrappedMonoid a) -> Int -> Box (WrappedMonoid a)

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

elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b

Methods

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

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

basicLength :: Vector (Dual a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a)

basicUnsafeIndexM :: Vector (Dual a) -> Int -> Box (Dual a)

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

elemseq :: Vector (Dual a) -> Dual a -> b -> b

Methods

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

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

basicLength :: Vector (Product a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a)

basicUnsafeIndexM :: Vector (Product a) -> Int -> Box (Product a)

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

elemseq :: Vector (Product a) -> Product a -> b -> b

Methods

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

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

basicLength :: Vector (Sum a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a)

basicUnsafeIndexM :: Vector (Sum a) -> Int -> Box (Sum a)

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

elemseq :: Vector (Sum a) -> Sum a -> b -> b

Methods

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

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

basicLength :: Vector (DoNotUnboxLazy a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a)

basicUnsafeIndexM :: Vector (DoNotUnboxLazy a) -> Int -> Box (DoNotUnboxLazy a)

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

elemseq :: Vector (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> b -> b

Methods

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

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

basicLength :: Vector (DoNotUnboxNormalForm a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a)

basicUnsafeIndexM :: Vector (DoNotUnboxNormalForm a) -> Int -> Box (DoNotUnboxNormalForm a)

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

elemseq :: Vector (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> b -> b

Methods

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

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

basicLength :: Vector (DoNotUnboxStrict a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a)

basicUnsafeIndexM :: Vector (DoNotUnboxStrict a) -> Int -> Box (DoNotUnboxStrict a)

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

elemseq :: Vector (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> b -> b

Methods

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

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

basicLength :: Vector (UnboxViaPrim a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (UnboxViaPrim a) -> Vector (UnboxViaPrim a)

basicUnsafeIndexM :: Vector (UnboxViaPrim a) -> Int -> Box (UnboxViaPrim a)

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

elemseq :: Vector (UnboxViaPrim a) -> UnboxViaPrim a -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s (Arg a b) -> ST s (Vector (Arg a b))

basicUnsafeThaw :: Vector (Arg a b) -> ST s (Mutable Vector s (Arg a b))

basicLength :: Vector (Arg a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b)

basicUnsafeIndexM :: Vector (Arg a b) -> Int -> Box (Arg a b)

basicUnsafeCopy :: Mutable Vector s (Arg a b) -> Vector (Arg a b) -> ST s ()

elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (As a b) -> ST s (Vector (As a b))

basicUnsafeThaw :: Vector (As a b) -> ST s (Mutable Vector s (As a b))

basicLength :: Vector (As a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (As a b) -> Vector (As a b)

basicUnsafeIndexM :: Vector (As a b) -> Int -> Box (As a b)

basicUnsafeCopy :: Mutable Vector s (As a b) -> Vector (As a b) -> ST s ()

elemseq :: Vector (As a b) -> As a b -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (TestPair a b) -> ST s (Vector (TestPair a b))

basicUnsafeThaw :: Vector (TestPair a b) -> ST s (Mutable Vector s (TestPair a b))

basicLength :: Vector (TestPair a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (TestPair a b) -> Vector (TestPair a b)

basicUnsafeIndexM :: Vector (TestPair a b) -> Int -> Box (TestPair a b)

basicUnsafeCopy :: Mutable Vector s (TestPair a b) -> Vector (TestPair a b) -> ST s ()

elemseq :: Vector (TestPair a b) -> TestPair a b -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b) -> ST s (Vector (a, b))

basicUnsafeThaw :: Vector (a, b) -> ST s (Mutable Vector s (a, b))

basicLength :: Vector (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b)

basicUnsafeIndexM :: Vector (a, b) -> Int -> Box (a, b)

basicUnsafeCopy :: Mutable Vector s (a, b) -> Vector (a, b) -> ST s ()

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (Const a b) -> ST s (Vector (Const a b))

basicUnsafeThaw :: Vector (Const a b) -> ST s (Mutable Vector s (Const a b))

basicLength :: Vector (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b)

basicUnsafeIndexM :: Vector (Const a b) -> Int -> Box (Const a b)

basicUnsafeCopy :: Mutable Vector s (Const a b) -> Vector (Const a b) -> ST s ()

elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (Alt f a) -> ST s (Vector (Alt f a))

basicUnsafeThaw :: Vector (Alt f a) -> ST s (Mutable Vector s (Alt f a))

basicLength :: Vector (Alt f a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a)

basicUnsafeIndexM :: Vector (Alt f a) -> Int -> Box (Alt f a)

basicUnsafeCopy :: Mutable Vector s (Alt f a) -> Vector (Alt f a) -> ST s ()

elemseq :: Vector (Alt f a) -> Alt f a -> b -> b

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c) -> ST s (Vector (a, b, c))

basicUnsafeThaw :: Vector (a, b, c) -> ST s (Mutable Vector s (a, b, c))

basicLength :: Vector (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c)

basicUnsafeIndexM :: Vector (a, b, c) -> Int -> Box (a, b, c)

basicUnsafeCopy :: Mutable Vector s (a, b, c) -> Vector (a, b, c) -> ST s ()

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c, d) -> ST s (Vector (a, b, c, d))

basicUnsafeThaw :: Vector (a, b, c, d) -> ST s (Mutable Vector s (a, b, c, d))

basicLength :: Vector (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d)

basicUnsafeIndexM :: Vector (a, b, c, d) -> Int -> Box (a, b, c, d)

basicUnsafeCopy :: Mutable Vector s (a, b, c, d) -> Vector (a, b, c, d) -> ST s ()

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0