(original) (raw)

{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE ScopedTypeVariables #-}

module Data.Vector.Storable.Mutable(

MVector(..), IOVector, STVector,

length, null,

slice, init, tail, take, drop, splitAt, unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,

overlaps,

new, unsafeNew, replicate, replicateM, generate, generateM, clone,

grow, unsafeGrow,

clear,

read, readMaybe, write, modify, modifyM, swap, exchange, unsafeRead, unsafeWrite, unsafeModify, unsafeModifyM, unsafeSwap, unsafeExchange,

mapM_, imapM_, forM_, iforM_, foldl, foldl', foldM, foldM', foldr, foldr', foldrM, foldrM', ifoldl, ifoldl', ifoldM, ifoldM', ifoldr, ifoldr', ifoldrM, ifoldrM',

nextPermutation, nextPermutationBy, prevPermutation, prevPermutationBy,

set, copy, move, unsafeCopy, unsafeMove,

unsafeCast, unsafeCoerceMVector,

unsafeFromForeignPtr, unsafeFromForeignPtr0, unsafeToForeignPtr, unsafeToForeignPtr0, unsafeWith,

Storable, PrimMonad, PrimState, RealWorld ) where

import Control.DeepSeq ( NFData(rnf) #if MIN_VERSION_deepseq(1,4,3) , NFData1(liftRnf) #endif )

import qualified Data.Vector.Generic.Mutable as G import Data.Vector.Storable.Internal

import Foreign.Storable import Foreign.ForeignPtr

import GHC.ForeignPtr (mallocPlainForeignPtrAlignedBytes) import GHC.Base ( Int(..) )

import Foreign.Ptr (castPtr,plusPtr) import Foreign.Marshal.Array ( advancePtr, copyArray, moveArray )

import Control.Monad.Primitive import Data.Primitive.Types (Prim) import qualified Data.Primitive.Types as DPT

import GHC.Word (Word8, Word16, Word32, Word64) import GHC.Ptr (Ptr(..))

import Prelude ( Ord, Bool, Maybe, IO, Ordering(..) , return, otherwise, error, undefined, max, div, quot, maxBound, show , (-), (*), (<), (>), (>=), (==), (&&), (||), (.), ($), (++) )

import Data.Typeable ( Typeable )

import Data.Coerce import Unsafe.Coerce

#define NOT_VECTOR_MODULE #include "vector.h"

type role MVector nominal nominal

unsafeCoerceMVector :: Coercible a b => MVector s a -> MVector s b unsafeCoerceMVector :: forall a b s. Coercible a b => MVector s a -> MVector s b unsafeCoerceMVector = MVector s a -> MVector s b forall a b. a -> b unsafeCoerce

data MVector s a = MVector {-# UNPACK #-} !Int {-# UNPACK #-} !(ForeignPtr a) deriving ( Typeable )

type IOVector = MVector RealWorld type STVector s = MVector s

instance NFData (MVector s a) where rnf :: MVector s a -> () rnf (MVector Int _ ForeignPtr a _) = ()

#if MIN_VERSION_deepseq(1,4,3) instance NFData1 (MVector s) where liftRnf :: forall a. (a -> ()) -> MVector s a -> () liftRnf a -> () _ (MVector Int _ ForeignPtr a _) = () #endif

instance Storable a => G.MVector MVector a where {-# INLINE basicLength #-} basicLength :: forall s. MVector s a -> Int basicLength (MVector Int n ForeignPtr a _) = Int n

{-# INLINE basicUnsafeSlice #-} basicUnsafeSlice :: forall s. Int -> Int -> MVector s a -> MVector s a basicUnsafeSlice Int j Int m (MVector Int _ ForeignPtr a fp) = Int -> ForeignPtr a -> MVector s a forall s a. Int -> ForeignPtr a -> MVector s a MVector Int m ((Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a forall a. (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a updPtr (Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int j) ForeignPtr a fp)

{-# INLINE basicOverlaps #-} basicOverlaps :: forall s. MVector s a -> MVector s a -> Bool basicOverlaps (MVector Int m ForeignPtr a fp) (MVector Int n ForeignPtr a fq) = Ptr a -> Ptr a -> Ptr a -> Bool forall {a}. Ord a => a -> a -> a -> Bool between Ptr a p Ptr a q (Ptr a q Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int n) Bool -> Bool -> Bool || Ptr a -> Ptr a -> Ptr a -> Bool forall {a}. Ord a => a -> a -> a -> Bool between Ptr a q Ptr a p (Ptr a p Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int m) where between :: a -> a -> a -> Bool between a x a y a z = a x a -> a -> Bool forall a. Ord a => a -> a -> Bool

= a y Bool -> Bool -> Bool && a x a -> a -> Bool forall a. Ord a => a -> a -> Bool < a z p :: Ptr a p = ForeignPtr a -> Ptr a forall a. ForeignPtr a -> Ptr a getPtr ForeignPtr a fp q :: Ptr a q = ForeignPtr a -> Ptr a forall a. ForeignPtr a -> Ptr a getPtr ForeignPtr a fq

{-# INLINE basicUnsafeNew #-} basicUnsafeNew :: forall s. Int -> ST s (MVector s a) basicUnsafeNew Int n | Int n Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int 0 = [Char] -> ST s (MVector s a) forall a. HasCallStack => [Char] -> a error ([Char] -> ST s (MVector s a)) -> [Char] -> ST s (MVector s a) forall a b. (a -> b) -> a -> b $ [Char] "Storable.basicUnsafeNew: negative length: " [Char] -> [Char] -> [Char] forall a. [a] -> [a] -> [a] ++ Int -> [Char] forall a. Show a => a -> [Char] show Int n | Int n Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

Int mx = [Char] -> ST s (MVector s a) forall a. HasCallStack => [Char] -> a error ([Char] -> ST s (MVector s a)) -> [Char] -> ST s (MVector s a) forall a b. (a -> b) -> a -> b $ [Char] "Storable.basicUnsafeNew: length too large: " [Char] -> [Char] -> [Char] forall a. [a] -> [a] -> [a] ++ Int -> [Char] forall a. Show a => a -> [Char] show Int n | Bool otherwise = IO (MVector s a) -> ST s (MVector s a) forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO (MVector s a) -> ST s (MVector s a)) -> IO (MVector s a) -> ST s (MVector s a) forall a b. (a -> b) -> a -> b $ do ForeignPtr a fp <- Int -> IO (ForeignPtr a) forall a. Storable a => Int -> IO (ForeignPtr a) mallocVector Int n MVector s a -> IO (MVector s a) forall a. a -> IO a forall (m :: * -> *) a. Monad m => a -> m a return (MVector s a -> IO (MVector s a)) -> MVector s a -> IO (MVector s a) forall a b. (a -> b) -> a -> b $ Int -> ForeignPtr a -> MVector s a forall s a. Int -> ForeignPtr a -> MVector s a MVector Int n ForeignPtr a fp where size :: Int size = a -> Int forall a. Storable a => a -> Int sizeOf (a forall a. HasCallStack => a undefined :: a) Int -> Int -> Int forall a. Ord a => a -> a -> a max Int 1 mx :: Int mx = Int forall a. Bounded a => a maxBound Int -> Int -> Int forall a. Integral a => a -> a -> a quot Int size :: Int

{-# INLINE basicInitialize #-} basicInitialize :: forall s. MVector s a -> ST s () basicInitialize = MVector s a -> ST s () MVector (PrimState (ST s)) a -> ST s () forall a (m :: * -> *). (Storable a, PrimMonad m) => MVector (PrimState m) a -> m () storableZero

{-# INLINE basicUnsafeRead #-} basicUnsafeRead :: forall s. MVector s a -> Int -> ST s a basicUnsafeRead (MVector Int _ ForeignPtr a fp) Int i = IO a -> ST s a forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO a -> ST s a) -> IO a -> ST s a forall a b. (a -> b) -> a -> b $ ForeignPtr a -> (Ptr a -> IO a) -> IO a forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp (Ptr a -> Int -> IO a forall a. Storable a => Ptr a -> Int -> IO a peekElemOff Int i)

{-# INLINE basicUnsafeWrite #-} basicUnsafeWrite :: forall s. MVector s a -> Int -> a -> ST s () basicUnsafeWrite (MVector Int _ ForeignPtr a fp) Int i a x = IO () -> ST s () forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO () -> ST s ()) -> IO () -> ST s () forall a b. (a -> b) -> a -> b $ ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a p -> Ptr a -> Int -> a -> IO () forall a. Storable a => Ptr a -> Int -> a -> IO () pokeElemOff Ptr a p Int i a x

{-# INLINE basicSet #-} basicSet :: forall s. MVector s a -> a -> ST s () basicSet = MVector s a -> a -> ST s () MVector (PrimState (ST s)) a -> a -> ST s () forall a (m :: * -> *). (Storable a, PrimMonad m) => MVector (PrimState m) a -> a -> m () storableSet

{-# INLINE basicUnsafeCopy #-} basicUnsafeCopy :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeCopy (MVector Int n ForeignPtr a fp) (MVector Int _ ForeignPtr a fq) = IO () -> ST s () forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO () -> ST s ()) -> IO () -> ST s () forall a b. (a -> b) -> a -> b $ ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a p -> ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fq ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a q -> Ptr a -> Ptr a -> Int -> IO () forall a. Storable a => Ptr a -> Ptr a -> Int -> IO () copyArray Ptr a p Ptr a q Int n

{-# INLINE basicUnsafeMove #-} basicUnsafeMove :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeMove (MVector Int n ForeignPtr a fp) (MVector Int _ ForeignPtr a fq) = IO () -> ST s () forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO () -> ST s ()) -> IO () -> ST s () forall a b. (a -> b) -> a -> b $ ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a p -> ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fq ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a q -> Ptr a -> Ptr a -> Int -> IO () forall a. Storable a => Ptr a -> Ptr a -> Int -> IO () moveArray Ptr a p Ptr a q Int n

storableZero :: forall a m. (Storable a, PrimMonad m) => MVector (PrimState m) a -> m () {-# INLINE storableZero #-} storableZero :: forall a (m :: * -> *). (Storable a, PrimMonad m) => MVector (PrimState m) a -> m () storableZero (MVector Int n ForeignPtr a fp) = IO () -> m () forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO () -> m ()) -> ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> m () forall b c a. (b -> c) -> (a -> b) -> a -> c . ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> m ()) -> (Ptr a -> IO ()) -> m () forall a b. (a -> b) -> a -> b $ \Ptr a ptr-> do Ptr Any -> Int -> Word8 -> IO () forall a c (m :: * -> *). (Prim c, PrimMonad m) => Ptr a -> Int -> c -> m () memsetPrimPtr_vector (Ptr a -> Ptr Any forall a b. Ptr a -> Ptr b castPtr Ptr a ptr) Int byteSize (Word8 0 :: Word8) where x :: a x :: a x = a forall a. HasCallStack => a undefined byteSize :: Int byteSize :: Int byteSize = Int n Int -> Int -> Int forall a. Num a => a -> a -> a

• a -> Int forall a. Storable a => a -> Int sizeOf a x

storableSet :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> a -> m () {-# INLINE storableSet #-} storableSet :: forall a (m :: * -> *). (Storable a, PrimMonad m) => MVector (PrimState m) a -> a -> m () storableSet (MVector Int n ForeignPtr a fp) a x | Int n Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == Int 0 = () -> m () forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return () | Bool otherwise = IO () -> m () forall (m1 :: * -> *) (m2 :: * -> *) a. (PrimBase m1, PrimMonad m2) => m1 a -> m2 a unsafePrimToPrim (IO () -> m ()) -> IO () -> m () forall a b. (a -> b) -> a -> b $ case a -> Int forall a. Storable a => a -> Int sizeOf a x of Int 1 -> Int -> ForeignPtr a -> a -> Word8 -> IO () forall a b. (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () storableSetAsPrim Int n ForeignPtr a fp a x (Word8 forall a. HasCallStack => a undefined :: Word8) Int 2 -> Int -> ForeignPtr a -> a -> Word16 -> IO () forall a b. (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () storableSetAsPrim Int n ForeignPtr a fp a x (Word16 forall a. HasCallStack => a undefined :: Word16) Int 4 -> Int -> ForeignPtr a -> a -> Word32 -> IO () forall a b. (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () storableSetAsPrim Int n ForeignPtr a fp a x (Word32 forall a. HasCallStack => a undefined :: Word32) #if !defined(ghcjs_HOST_OS) Int 8 -> Int -> ForeignPtr a -> a -> Word64 -> IO () forall a b. (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () storableSetAsPrim Int n ForeignPtr a fp a x (Word64 forall a. HasCallStack => a undefined :: Word64) #endif Int _ -> ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \Ptr a p -> do Ptr a -> a -> IO () forall a. Storable a => Ptr a -> a -> IO () poke Ptr a p a x

                   let do_set :: Int -> IO ()

do_set Int i | Int 2Int -> Int -> Int forall a. Num a => a -> a -> a *Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int n = do Ptr a -> Ptr a -> Int -> IO () forall a. Storable a => Ptr a -> Ptr a -> Int -> IO () copyArray (Ptr a p Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int i) Ptr a p Int i Int -> IO () do_set (Int 2Int -> Int -> Int forall a. Num a => a -> a -> a *Int i) | Bool otherwise = Ptr a -> Ptr a -> Int -> IO () forall a. Storable a => Ptr a -> Ptr a -> Int -> IO () copyArray (Ptr a p Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int i) Ptr a p (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i)

                   Int -> IO ()

do_set Int 1

storableSetAsPrim :: forall a b . (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () {-# INLINE [0] storableSetAsPrim #-} storableSetAsPrim :: forall a b. (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO () storableSetAsPrim Int n ForeignPtr a fp a x b _y = ForeignPtr a -> (Ptr a -> IO ()) -> IO () forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b unsafeWithForeignPtr ForeignPtr a fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO () forall a b. (a -> b) -> a -> b $ \ Ptr a ptr -> do Ptr a -> a -> IO () forall a. Storable a => Ptr a -> a -> IO () poke Ptr a ptr a x

b

w<- Ptr b -> Int -> IO b forall a (m :: * -> *). (Prim a, PrimMonad m) => Ptr a -> Int -> m a peakPrimPtr_vector (Ptr a -> Ptr b forall a b. Ptr a -> Ptr b castPtr Ptr a ptr :: Ptr b) Int 0 Ptr Any -> Int -> b -> IO () forall a c (m :: * -> *). (Prim c, PrimMonad m) => Ptr a -> Int -> c -> m () memsetPrimPtr_vector (Ptr a -> Ptr Any forall a b. Ptr a -> Ptr b castPtr Ptr a ptr Ptr Any -> Int -> Ptr Any forall a b. Ptr a -> Int -> Ptr b plusPtr a -> Int forall a. Storable a => a -> Int sizeOf a x ) (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int

1. b w

memsetPrimPtr_vector :: forall a c m. (Prim c, PrimMonad m) => Ptr a -> Int -> c -> m () memsetPrimPtr_vector :: forall a c (m :: * -> *). (Prim c, PrimMonad m) => Ptr a -> Int -> c -> m () memsetPrimPtr_vector (Ptr Addr# addr#) (I# Int# n#) c x = (State# (PrimState m) -> State# (PrimState m)) -> m () forall (m :: * -> *). PrimMonad m => (State# (PrimState m) -> State# (PrimState m)) -> m () primitive_ (Addr# -> Int# -> Int# -> c -> State# (PrimState m) -> State# (PrimState m) forall s. Addr# -> Int# -> Int# -> c -> State# s -> State# s forall a s. Prim a => Addr# -> Int# -> Int# -> a -> State# s -> State# s DPT.setOffAddr# Addr# addr# Int# 0# Int# n# c x) {-# INLINE memsetPrimPtr_vector #-}

peakPrimPtr_vector :: (Prim a, PrimMonad m) => Ptr a -> Int -> m a peakPrimPtr_vector :: forall a (m :: * -> *). (Prim a, PrimMonad m) => Ptr a -> Int -> m a peakPrimPtr_vector (Ptr Addr# addr#) (I# Int# i#) = (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a forall a. (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a forall (m :: * -> *) a. PrimMonad m => (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a primitive (Addr# -> Int# -> State# (PrimState m) -> (# State# (PrimState m), a #) forall s. Addr# -> Int# -> State# s -> (# State# s, a #) forall a s. Prim a => Addr# -> Int# -> State# s -> (# State# s, a #) DPT.readOffAddr# Addr# addr# Int# i#) {-# INLINE peakPrimPtr_vector #-}

{-# INLINE mallocVector #-} mallocVector :: Storable a => Int -> IO (ForeignPtr a) mallocVector :: forall a. Storable a => Int -> IO (ForeignPtr a) mallocVector = a -> Int -> IO (ForeignPtr a) forall b. Storable b => b -> Int -> IO (ForeignPtr b) doMalloc a forall a. HasCallStack => a undefined where doMalloc :: Storable b => b -> Int -> IO (ForeignPtr b) doMalloc :: forall b. Storable b => b -> Int -> IO (ForeignPtr b) doMalloc b dummy Int size = Int -> Int -> IO (ForeignPtr b) forall a. Int -> Int -> IO (ForeignPtr a) mallocPlainForeignPtrAlignedBytes (Int size Int -> Int -> Int forall a. Num a => a -> a -> a

• b -> Int forall a. Storable a => a -> Int sizeOf b dummy) (b -> Int forall a. Storable a => a -> Int alignment b dummy)

length :: Storable a => MVector s a -> Int {-# INLINE length #-} length :: forall a s. Storable a => MVector s a -> Int length = MVector s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int G.length

null :: Storable a => MVector s a -> Bool {-# INLINE null #-} null :: forall a s. Storable a => MVector s a -> Bool null = MVector s a -> Bool forall (v :: * -> * -> *) a s. MVector v a => v s a -> Bool G.null

slice :: Storable a => Int
-> Int
-> MVector s a -> MVector s a {-# INLINE slice #-} slice :: forall a s. Storable a => Int -> Int -> MVector s a -> MVector s a slice = Int -> Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. (HasCallStack, MVector v a) => Int -> Int -> v s a -> v s a G.slice

take :: Storable a => Int -> MVector s a -> MVector s a {-# INLINE take #-} take :: forall a s. Storable a => Int -> MVector s a -> MVector s a take = Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a G.take

drop :: Storable a => Int -> MVector s a -> MVector s a {-# INLINE drop #-} drop :: forall a s. Storable a => Int -> MVector s a -> MVector s a drop = Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a G.drop

splitAt :: Storable a => Int -> MVector s a -> (MVector s a, MVector s a) {-# INLINE splitAt #-} splitAt :: forall a s. Storable a => Int -> MVector s a -> (MVector s a, MVector s a) splitAt = Int -> MVector s a -> (MVector s a, MVector s a) forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> (v s a, v s a) G.splitAt

init :: Storable a => MVector s a -> MVector s a {-# INLINE init #-} init :: forall a s. Storable a => MVector s a -> MVector s a init = MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a G.init

tail :: Storable a => MVector s a -> MVector s a {-# INLINE tail #-} tail :: forall a s. Storable a => MVector s a -> MVector s a tail = MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a G.tail

unsafeSlice :: Storable a => Int
-> Int
-> MVector s a -> MVector s a {-# INLINE unsafeSlice #-} unsafeSlice :: forall a s. Storable a => Int -> Int -> MVector s a -> MVector s a unsafeSlice = Int -> Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a G.unsafeSlice

unsafeTake :: Storable a => Int -> MVector s a -> MVector s a {-# INLINE unsafeTake #-} unsafeTake :: forall a s. Storable a => Int -> MVector s a -> MVector s a unsafeTake = Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a G.unsafeTake

unsafeDrop :: Storable a => Int -> MVector s a -> MVector s a {-# INLINE unsafeDrop #-} unsafeDrop :: forall a s. Storable a => Int -> MVector s a -> MVector s a unsafeDrop = Int -> MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a G.unsafeDrop

unsafeInit :: Storable a => MVector s a -> MVector s a {-# INLINE unsafeInit #-} unsafeInit :: forall a s. Storable a => MVector s a -> MVector s a unsafeInit = MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a G.unsafeInit

unsafeTail :: Storable a => MVector s a -> MVector s a {-# INLINE unsafeTail #-} unsafeTail :: forall a s. Storable a => MVector s a -> MVector s a unsafeTail = MVector s a -> MVector s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a G.unsafeTail

overlaps :: Storable a => MVector s a -> MVector s a -> Bool {-# INLINE overlaps #-} overlaps :: forall a s. Storable a => MVector s a -> MVector s a -> Bool overlaps = MVector s a -> MVector s a -> Bool forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> Bool G.overlaps

new :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) {-# INLINE new #-} new :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) new = Int -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) G.new

unsafeNew :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) {-# INLINE unsafeNew #-} unsafeNew :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a) unsafeNew = Int -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) G.unsafeNew

replicate :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a) {-# INLINE replicate #-} replicate :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a) replicate = Int -> a -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a) G.replicate

replicateM :: (PrimMonad m, Storable a) => Int -> m a -> m (MVector (PrimState m) a) {-# INLINE replicateM #-} replicateM :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> m a -> m (MVector (PrimState m) a) replicateM = Int -> m a -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a) G.replicateM

generate :: (PrimMonad m, Storable a) => Int -> (Int -> a) -> m (MVector (PrimState m) a) {-# INLINE generate #-} generate :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> (Int -> a) -> m (MVector (PrimState m) a) generate = Int -> (Int -> a) -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> (Int -> a) -> m (v (PrimState m) a) G.generate

generateM :: (PrimMonad m, Storable a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a) {-# INLINE generateM #-} generateM :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => Int -> (Int -> m a) -> m (MVector (PrimState m) a) generateM = Int -> (Int -> m a) -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> (Int -> m a) -> m (v (PrimState m) a) G.generateM

clone :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m (MVector (PrimState m) a) {-# INLINE clone #-} clone :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> m (MVector (PrimState m) a) clone = MVector (PrimState m) a -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) G.clone

grow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) {-# INLINE grow #-} grow :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) grow = MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) G.grow

unsafeGrow :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) {-# INLINE unsafeGrow #-} unsafeGrow :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) unsafeGrow = MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) G.unsafeGrow

clear :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m () {-# INLINE clear #-} clear :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> m () clear = MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m () G.clear

read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a {-# INLINE read #-} read :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a read = MVector (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a G.read

readMaybe :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (Maybe a) {-# INLINE readMaybe #-} readMaybe :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m (Maybe a) readMaybe = MVector (PrimState m) a -> Int -> m (Maybe a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (Maybe a) G.readMaybe

write :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () {-# INLINE write #-} write :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () write = MVector (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () G.write

modify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE modify #-} modify :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () modify = MVector (PrimState m) a -> (a -> a) -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () G.modify

modifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE modifyM #-} modifyM :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () modifyM = MVector (PrimState m) a -> (a -> m a) -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () G.modifyM

swap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () {-# INLINE swap #-} swap :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () swap = MVector (PrimState m) a -> Int -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () G.swap

exchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a {-# INLINE exchange #-} exchange :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a exchange = MVector (PrimState m) a -> Int -> a -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a G.exchange

unsafeRead :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a {-# INLINE unsafeRead #-} unsafeRead :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a unsafeRead = MVector (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a G.unsafeRead

unsafeWrite :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () {-# INLINE unsafeWrite #-} unsafeWrite :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m () unsafeWrite = MVector (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () G.unsafeWrite

unsafeModify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE unsafeModify #-} unsafeModify :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () unsafeModify = MVector (PrimState m) a -> (a -> a) -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () G.unsafeModify

unsafeModifyM :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE unsafeModifyM #-} unsafeModifyM :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () unsafeModifyM = MVector (PrimState m) a -> (a -> m a) -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () G.unsafeModifyM

unsafeSwap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () {-# INLINE unsafeSwap #-} unsafeSwap :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m () unsafeSwap = MVector (PrimState m) a -> Int -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () G.unsafeSwap

unsafeExchange :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a {-# INLINE unsafeExchange #-} unsafeExchange :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m a unsafeExchange = MVector (PrimState m) a -> Int -> a -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a G.unsafeExchange

set :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> a -> m () {-# INLINE set #-} set :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> a -> m () set = MVector (PrimState m) a -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m () G.set

copy :: (PrimMonad m, Storable a) => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE copy #-} copy :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m () copy = MVector (PrimState m) a -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () G.copy

unsafeCopy :: (PrimMonad m, Storable a) => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE unsafeCopy #-} unsafeCopy :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m () unsafeCopy = MVector (PrimState m) a -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () G.unsafeCopy

move :: (PrimMonad m, Storable a) => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE move #-} move :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m () move = MVector (PrimState m) a -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () G.move

unsafeMove :: (PrimMonad m, Storable a) => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE unsafeMove #-} unsafeMove :: forall (m :: * -> *) a. (PrimMonad m, Storable a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m () unsafeMove = MVector (PrimState m) a -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () G.unsafeMove

nextPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool {-# INLINE nextPermutation #-} nextPermutation :: forall (m :: * -> *) e. (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool nextPermutation = MVector (PrimState m) e -> m Bool forall (m :: * -> *) e (v :: * -> * -> *). (PrimMonad m, Ord e, MVector v e) => v (PrimState m) e -> m Bool G.nextPermutation

nextPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool {-# INLINE nextPermutationBy #-} nextPermutationBy :: forall (m :: * -> *) e. (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool nextPermutationBy = (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool G.nextPermutationBy

prevPermutation :: (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool {-# INLINE prevPermutation #-} prevPermutation :: forall (m :: * -> *) e. (PrimMonad m, Storable e, Ord e) => MVector (PrimState m) e -> m Bool prevPermutation = MVector (PrimState m) e -> m Bool forall (m :: * -> *) e (v :: * -> * -> *). (PrimMonad m, Ord e, MVector v e) => v (PrimState m) e -> m Bool G.prevPermutation

prevPermutationBy :: (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool {-# INLINE prevPermutationBy #-} prevPermutationBy :: forall (m :: * -> *) e. (PrimMonad m, Storable e) => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool prevPermutationBy = (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool G.prevPermutationBy

mapM_ :: (PrimMonad m, Storable a) => (a -> m b) -> MVector (PrimState m) a -> m () {-# INLINE mapM_ #-} mapM_ :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (a -> m b) -> MVector (PrimState m) a -> m () mapM_ = (a -> m b) -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> m b) -> v (PrimState m) a -> m () G.mapM_

imapM_ :: (PrimMonad m, Storable a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m () {-# INLINE imapM_ #-} imapM_ :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m () imapM_ = (Int -> a -> m b) -> MVector (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> m b) -> v (PrimState m) a -> m () G.imapM_

forM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m b) -> m () {-# INLINE forM_ #-} forM_ :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> m b) -> m () forM_ = MVector (PrimState m) a -> (a -> m b) -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m b) -> m () G.forM_

iforM_ :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m () {-# INLINE iforM_ #-} iforM_ :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => MVector (PrimState m) a -> (Int -> a -> m b) -> m () iforM_ = MVector (PrimState m) a -> (Int -> a -> m b) -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => v (PrimState m) a -> (Int -> a -> m b) -> m () G.iforM_

foldl :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldl #-} foldl :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b foldl = (b -> a -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b G.foldl

foldl' :: (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldl' #-} foldl' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b foldl' = (b -> a -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b G.foldl'

ifoldl :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldl #-} ifoldl :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b ifoldl = (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b G.ifoldl

ifoldl' :: (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldl' #-} ifoldl' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b ifoldl' = (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b G.ifoldl'

foldr :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldr #-} foldr :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b foldr = (a -> b -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b G.foldr

foldr' :: (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldr' #-} foldr' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b foldr' = (a -> b -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b G.foldr'

ifoldr :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldr #-} ifoldr :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b ifoldr = (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b G.ifoldr

ifoldr' :: (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldr' #-} ifoldr' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b ifoldr' = (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b G.ifoldr'

foldM :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldM #-} foldM :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b foldM = (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b G.foldM

foldM' :: (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldM' #-} foldM' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b foldM' = (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b G.foldM'

ifoldM :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldM #-} ifoldM :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b ifoldM = (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b G.ifoldM

ifoldM' :: (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldM' #-} ifoldM' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b ifoldM' = (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b G.ifoldM'

foldrM :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldrM #-} foldrM :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b foldrM = (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b G.foldrM

foldrM' :: (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldrM' #-} foldrM' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b foldrM' = (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b G.foldrM'

ifoldrM :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldrM #-} ifoldrM :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b ifoldrM = (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b G.ifoldrM

ifoldrM' :: (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldrM' #-} ifoldrM' :: forall (m :: * -> *) a b. (PrimMonad m, Storable a) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b ifoldrM' = (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b G.ifoldrM'

unsafeCast :: forall a b s. (Storable a, Storable b) => MVector s a -> MVector s b {-# INLINE unsafeCast #-} unsafeCast :: forall a b s. (Storable a, Storable b) => MVector s a -> MVector s b unsafeCast (MVector Int n ForeignPtr a fp) = Int -> ForeignPtr b -> MVector s b forall s a. Int -> ForeignPtr a -> MVector s a MVector ((Int n Int -> Int -> Int forall a. Num a => a -> a -> a

• a -> Int forall a. Storable a => a -> Int sizeOf (a forall a. HasCallStack => a undefined :: a)) Int -> Int -> Int forall a. Integral a => a -> a -> a div b -> Int forall a. Storable a => a -> Int sizeOf (b forall a. HasCallStack => a undefined :: b)) (ForeignPtr a -> ForeignPtr b

forall a b. ForeignPtr a -> ForeignPtr b castForeignPtr ForeignPtr a fp)

unsafeFromForeignPtr :: Storable a => ForeignPtr a
-> Int
-> Int
-> MVector s a {-# INLINE_FUSED unsafeFromForeignPtr #-} unsafeFromForeignPtr :: forall a s. Storable a => ForeignPtr a -> Int -> Int -> MVector s a unsafeFromForeignPtr ForeignPtr a fp Int i Int n = ForeignPtr a -> Int -> MVector s a forall a s. ForeignPtr a -> Int -> MVector s a unsafeFromForeignPtr0 ForeignPtr a fp' Int n where fp' :: ForeignPtr a fp' = (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a forall a. (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a updPtr (Ptr a -> Int -> Ptr a forall a. Storable a => Ptr a -> Int -> Ptr a advancePtr Int i) ForeignPtr a fp

{-# RULES "unsafeFromForeignPtr fp 0 n -> unsafeFromForeignPtr0 fp n " forall fp n. unsafeFromForeignPtr fp 0 n = unsafeFromForeignPtr0 fp n #-}

unsafeFromForeignPtr0 :: ForeignPtr a
-> Int
-> MVector s a {-# INLINE unsafeFromForeignPtr0 #-} unsafeFromForeignPtr0 :: forall a s. ForeignPtr a -> Int -> MVector s a unsafeFromForeignPtr0 ForeignPtr a fp Int n = Int -> ForeignPtr a -> MVector s a forall s a. Int -> ForeignPtr a -> MVector s a MVector Int n ForeignPtr a fp

unsafeToForeignPtr :: MVector s a -> (ForeignPtr a, Int, Int) {-# INLINE unsafeToForeignPtr #-} unsafeToForeignPtr :: forall s a. MVector s a -> (ForeignPtr a, Int, Int) unsafeToForeignPtr (MVector Int n ForeignPtr a fp) = (ForeignPtr a fp, Int 0, Int n)

unsafeToForeignPtr0 :: MVector s a -> (ForeignPtr a, Int) {-# INLINE unsafeToForeignPtr0 #-} unsafeToForeignPtr0 :: forall s a. MVector s a -> (ForeignPtr a, Int) unsafeToForeignPtr0 (MVector Int n ForeignPtr a fp) = (ForeignPtr a fp, Int n)

unsafeWith :: Storable a => IOVector a -> (Ptr a -> IO b) -> IO b {-# INLINE unsafeWith #-} unsafeWith :: forall a b. Storable a => IOVector a -> (Ptr a -> IO b) -> IO b unsafeWith (MVector Int _ ForeignPtr a fp) = ForeignPtr a -> (Ptr a -> IO b) -> IO b forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b withForeignPtr ForeignPtr a fp