(original) (raw)

{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE TypeFamilies #-}

module Data.Vector.Mutable (

MVector(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,

fromMutableArray, toMutableArray,

PrimMonad, PrimState, RealWorld ) where

import Control.Monad (when, liftM) import qualified Data.Vector.Generic.Mutable as G import Data.Vector.Internal.Check import Data.Primitive.Array import Control.Monad.Primitive

import Prelude ( Ord, Monad, Bool, Ordering(..), Int, Maybe , compare, return, otherwise, error , (>>=), (+), (-), (*), (<), (>), (>=), (&&), (||), ($), (>>) )

import Data.Typeable ( Typeable )

#include "vector.h"

type role MVector nominal representational

data MVector s a = MVector { forall s a. MVector s a -> Int _offset :: {-# UNPACK #-} !Int

                       , forall s a. MVector s a -> Int

_size :: {-# UNPACK #-} !Int

                       , forall s a. MVector s a -> MutableArray s a

_array :: {-# UNPACK #-} !(MutableArray s a)

                       }
    deriving ( Typeable )

type IOVector = MVector RealWorld type STVector s = MVector s

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

{-# INLINE basicUnsafeSlice #-} basicUnsafeSlice :: forall s. Int -> Int -> MVector s a -> MVector s a basicUnsafeSlice Int j Int m (MVector Int i Int _ MutableArray s a arr) = Int -> Int -> MutableArray s a -> MVector s a forall s a. Int -> Int -> MutableArray s a -> MVector s a MVector (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int j) Int m MutableArray s a arr

{-# INLINE basicOverlaps #-} basicOverlaps :: forall s. MVector s a -> MVector s a -> Bool basicOverlaps (MVector Int i Int m MutableArray s a arr1) (MVector Int j Int n MutableArray s a arr2) = MutableArray s a -> MutableArray s a -> Bool forall s a. MutableArray s a -> MutableArray s a -> Bool sameMutableArray MutableArray s a arr1 MutableArray s a arr2 Bool -> Bool -> Bool && (Int -> Int -> Int -> Bool forall {a}. Ord a => a -> a -> a -> Bool between Int i Int j (Int jInt -> Int -> Int forall a. Num a => a -> a -> a +Int n) Bool -> Bool -> Bool || Int -> Int -> Int -> Bool forall {a}. Ord a => a -> a -> a -> Bool between Int j Int i (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +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

{-# INLINE basicUnsafeNew #-} basicUnsafeNew :: forall s. Int -> ST s (MVector s a) basicUnsafeNew Int n = do MutableArray s a arr <- Int -> a -> ST s (MutableArray (PrimState (ST s)) a) forall (m :: * -> *) a. PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) newArray Int n a forall a. a uninitialised MVector s a -> ST s (MVector s a) forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> MutableArray s a -> MVector s a forall s a. Int -> Int -> MutableArray s a -> MVector s a MVector Int 0 Int n MutableArray s a arr)

{-# INLINE basicInitialize #-}

basicInitialize :: forall s. MVector s a -> ST s () basicInitialize MVector s a _ = () -> ST s () forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return ()

{-# INLINE basicUnsafeReplicate #-} basicUnsafeReplicate :: forall s. Int -> a -> ST s (MVector s a) basicUnsafeReplicate Int n a x = do MutableArray s a arr <- Int -> a -> ST s (MutableArray (PrimState (ST s)) a) forall (m :: * -> *) a. PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) newArray Int n a x MVector s a -> ST s (MVector s a) forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> MutableArray s a -> MVector s a forall s a. Int -> Int -> MutableArray s a -> MVector s a MVector Int 0 Int n MutableArray s a arr)

{-# INLINE basicUnsafeRead #-} basicUnsafeRead :: forall s. MVector s a -> Int -> ST s a basicUnsafeRead (MVector Int i Int _ MutableArray s a arr) Int j = MutableArray (PrimState (ST s)) a -> Int -> ST s a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray s a MutableArray (PrimState (ST s)) a arr (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int j)

{-# INLINE basicUnsafeWrite #-} basicUnsafeWrite :: forall s. MVector s a -> Int -> a -> ST s () basicUnsafeWrite (MVector Int i Int _ MutableArray s a arr) Int j a x = MutableArray (PrimState (ST s)) a -> Int -> a -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray s a MutableArray (PrimState (ST s)) a arr (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int j) a x

{-# INLINE basicUnsafeCopy #-} basicUnsafeCopy :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeCopy (MVector Int i Int n MutableArray s a dst) (MVector Int j Int _ MutableArray s a src) = MutableArray (PrimState (ST s)) a -> Int -> MutableArray (PrimState (ST s)) a -> Int -> Int -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> MutableArray (PrimState m) a -> Int -> Int -> m () copyMutableArray MutableArray s a MutableArray (PrimState (ST s)) a dst Int i MutableArray s a MutableArray (PrimState (ST s)) a src Int j Int n

basicUnsafeMove :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeMove dst :: MVector s a dst@(MVector Int iDst Int n MutableArray s a arrDst) src :: MVector s a src@(MVector Int iSrc Int _ MutableArray s a arrSrc) = case Int n of Int 0 -> () -> ST s () forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return () Int 1 -> MutableArray (PrimState (ST s)) a -> Int -> ST s a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray s a MutableArray (PrimState (ST s)) a arrSrc Int iSrc ST s a -> (a -> ST s ()) -> ST s () forall a b. ST s a -> (a -> ST s b) -> ST s b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= MutableArray (PrimState (ST s)) a -> Int -> a -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray s a MutableArray (PrimState (ST s)) a arrDst Int iDst Int 2 -> do a x <- MutableArray (PrimState (ST s)) a -> Int -> ST s a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray s a MutableArray (PrimState (ST s)) a arrSrc Int iSrc a y <- MutableArray (PrimState (ST s)) a -> Int -> ST s a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray s a MutableArray (PrimState (ST s)) a arrSrc (Int iSrc Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1.          MutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()

forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray s a MutableArray (PrimState (ST s)) a arrDst Int iDst a x MutableArray (PrimState (ST s)) a -> Int -> a -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray s a MutableArray (PrimState (ST s)) a arrDst (Int iDst Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. a y Int

_ | MVector s a -> MVector s a -> Bool forall s a. MVector s a -> MVector s a -> Bool overlaps MVector s a dst MVector s a src -> case Int -> Int -> Ordering forall a. Ord a => a -> a -> Ordering compare Int iDst Int iSrc of Ordering LT -> MutableArray (PrimState (ST s)) a -> Int -> Int -> Int -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveBackwards MutableArray s a MutableArray (PrimState (ST s)) a arrDst Int iDst Int iSrc Int n Ordering EQ -> () -> ST s () forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return () Ordering GT | (Int iDst Int -> Int -> Int forall a. Num a => a -> a -> a

• Int iSrc) Int -> Int -> Int forall a. Num a => a -> a -> a

• Int 2 Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int n -> MutableArray (PrimState (ST s)) a -> Int -> Int -> Int -> ST s ()

forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsLargeOverlap MutableArray s a MutableArray (PrimState (ST s)) a arrDst Int iDst Int iSrc Int n | Bool otherwise -> MutableArray (PrimState (ST s)) a -> Int -> Int -> Int -> ST s () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsSmallOverlap MutableArray s a MutableArray (PrimState (ST s)) a arrDst Int iDst Int iSrc Int n | Bool otherwise -> MVector s a -> MVector s a -> ST s () forall s. MVector s a -> MVector s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () G.basicUnsafeCopy MVector s a dst MVector s a src

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

{-# INLINE moveBackwards #-} moveBackwards :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveBackwards :: forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveBackwards !MutableArray (PrimState m) a arr !Int dstOff !Int srcOff !Int len = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Internal String "not a backwards move" (Int dstOff Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int srcOff) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Int -> (Int -> m ()) -> m () forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM Int len ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m () forall a b. (a -> b) -> a -> b $ \ Int i -> MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a arr (Int srcOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i) m a -> (a -> m ()) -> m () forall a b. m a -> (a -> m b) -> m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

  = MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a arr (Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i)

{-# INLINE moveForwardsSmallOverlap #-}

moveForwardsSmallOverlap :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsSmallOverlap :: forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsSmallOverlap !MutableArray (PrimState m) a arr !Int dstOff !Int srcOff !Int len = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Internal String "not a forward move" (Int dstOff Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

Int srcOff) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ do MutableArray (PrimState m) a tmp <- Int -> a -> m (MutableArray (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) newArray Int overlap a forall a. a uninitialised Int -> (Int -> m ()) -> m () forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM Int overlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m () forall a b. (a -> b) -> a -> b $ \ Int i -> MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a arr (Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i) m a -> (a -> m ()) -> m () forall a b. m a -> (a -> m b) -> m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

  = MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a tmp Int i Int -> (Int -> m ()) -> m ()

forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM Int nonOverlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m () forall a b. (a -> b) -> a -> b $ \ Int i -> MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a arr (Int srcOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i) m a -> (a -> m ()) -> m () forall a b. m a -> (a -> m b) -> m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

  = MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a arr (Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i) Int -> (Int -> m ()) -> m ()

forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM Int overlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m () forall a b. (a -> b) -> a -> b $ \ Int i -> MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a tmp Int i m a -> (a -> m ()) -> m () forall a b. m a -> (a -> m b) -> m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a arr (Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int nonOverlap Int -> Int -> Int forall a. Num a => a -> a -> a
• Int i) where nonOverlap :: Int nonOverlap = Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int srcOff; overlap :: Int overlap = Int len Int -> Int -> Int forall a. Num a => a -> a -> a
• Int nonOverlap

moveForwardsLargeOverlap :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsLargeOverlap :: forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m () moveForwardsLargeOverlap !MutableArray (PrimState m) a arr !Int dstOff !Int srcOff !Int len = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Internal String "not a forward move" (Int dstOff Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

Int srcOff) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ do MutableArray (PrimState m) a queue <- Int -> a -> m (MutableArray (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a) newArray Int nonOverlap a forall a. a uninitialised Int -> (Int -> m ()) -> m () forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM Int nonOverlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m () forall a b. (a -> b) -> a -> b $ \ Int i -> MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a arr (Int srcOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int i) m a -> (a -> m ()) -> m () forall a b. m a -> (a -> m b) -> m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

  = MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a queue Int i let mov :: Int -> Int -> m ()

mov !Int i !Int qTop = Bool -> m () -> m () forall (f :: * -> *). Applicative f => Bool -> f () -> f () when (Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int len) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ do a

x <- MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a arr Int i a y <- MutableArray (PrimState m) a -> Int -> m a forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> m a readArray MutableArray (PrimState m) a queue Int qTop MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a arr Int i a y MutableArray (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m () writeArray MutableArray (PrimState m) a queue Int qTop a x Int -> Int -> m () mov (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int

1. (if Int qTop Int -> Int -> Int forall a. Num a => a -> a -> a

• Int 1 Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

  = Int nonOverlap then Int 0 else Int qTop Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. Int -> Int -> m ()

mov Int dstOff Int 0 where nonOverlap :: Int nonOverlap = Int dstOff Int -> Int -> Int forall a. Num a => a -> a -> a

• Int srcOff

{-# INLINE loopM #-} loopM :: Monad m => Int -> (Int -> m a) -> m () loopM :: forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m () loopM !Int n Int -> m a k = let go :: Int -> m () go Int i = Bool -> m () -> m () forall (f :: * -> *). Applicative f => Bool -> f () -> f () when (Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int n) (Int -> m a k Int i m a -> m () -> m () forall a b. m a -> m b -> m b forall (m :: * -> *) a b. Monad m => m a -> m b -> m b

Int -> m () go (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1)) in Int -> m () go Int 0

uninitialised :: a uninitialised :: forall a. a uninitialised = String -> a forall a. HasCallStack => String -> a error String "Data.Vector.Mutable: uninitialised element. If you are trying to compact a vector, use the 'Data.Vector.force' function to remove uninitialised elements from the underlying array."

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

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

slice :: Int
-> Int
-> MVector s a -> MVector s a {-# INLINE slice #-} slice :: forall s 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 :: Int -> MVector s a -> MVector s a {-# INLINE take #-} take :: forall s 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 :: Int -> MVector s a -> MVector s a {-# INLINE drop #-} drop :: forall s 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 :: Int -> MVector s a -> (MVector s a, MVector s a) {-# INLINE splitAt #-} splitAt :: forall s 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 :: MVector s a -> MVector s a {-# INLINE init #-} init :: forall s 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 :: MVector s a -> MVector s a {-# INLINE tail #-} tail :: forall s 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 :: Int
-> Int
-> MVector s a -> MVector s a {-# INLINE unsafeSlice #-} unsafeSlice :: forall s 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 :: Int -> MVector s a -> MVector s a {-# INLINE unsafeTake #-} unsafeTake :: forall s 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 :: Int -> MVector s a -> MVector s a {-# INLINE unsafeDrop #-} unsafeDrop :: forall s 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 :: MVector s a -> MVector s a {-# INLINE unsafeInit #-} unsafeInit :: forall s 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 :: MVector s a -> MVector s a {-# INLINE unsafeTail #-} unsafeTail :: forall s 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 :: MVector s a -> MVector s a -> Bool {-# INLINE overlaps #-} overlaps :: forall s 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 => Int -> m (MVector (PrimState m) a) {-# INLINE new #-} new :: forall (m :: * -> *) a. PrimMonad m => 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 => Int -> m (MVector (PrimState m) a) {-# INLINE unsafeNew #-} unsafeNew :: forall (m :: * -> *) a. PrimMonad m => 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 => Int -> a -> m (MVector (PrimState m) a) {-# INLINE replicate #-} replicate :: forall (m :: * -> *) a. PrimMonad m => 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 => Int -> m a -> m (MVector (PrimState m) a) {-# INLINE replicateM #-} replicateM :: forall (m :: * -> *) a. PrimMonad m => 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) => Int -> (Int -> a) -> m (MVector (PrimState m) a) {-# INLINE generate #-} generate :: forall (m :: * -> *) a. PrimMonad m => 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) => Int -> (Int -> m a) -> m (MVector (PrimState m) a) {-# INLINE generateM #-} generateM :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> m (MVector (PrimState m) a) {-# INLINE clone #-} clone :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) {-# INLINE grow #-} grow :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) {-# INLINE unsafeGrow #-} unsafeGrow :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> m () {-# INLINE clear #-} clear :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> m a {-# INLINE read #-} read :: forall (m :: * -> *) a. PrimMonad m => 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) => MVector (PrimState m) a -> Int -> m (Maybe a) {-# INLINE readMaybe #-} readMaybe :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> a -> m () {-# INLINE write #-} write :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE modify #-} modify :: forall (m :: * -> *) a. PrimMonad m => 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) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE modifyM #-} modifyM :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> Int -> m () {-# INLINE swap #-} swap :: forall (m :: * -> *) a. PrimMonad m => 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) => MVector (PrimState m) a -> Int -> a -> m a {-# INLINE exchange #-} exchange :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> m a {-# INLINE unsafeRead #-} unsafeRead :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> a -> m () {-# INLINE unsafeWrite #-} unsafeWrite :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE unsafeModify #-} unsafeModify :: forall (m :: * -> *) a. PrimMonad m => 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) => MVector (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE unsafeModifyM #-} unsafeModifyM :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> Int -> Int -> m () {-# INLINE unsafeSwap #-} unsafeSwap :: forall (m :: * -> *) a. PrimMonad m => 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) => MVector (PrimState m) a -> Int -> a -> m a {-# INLINE unsafeExchange #-} unsafeExchange :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a -> a -> m () {-# INLINE set #-} set :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE copy #-} copy :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE unsafeCopy #-} unsafeCopy :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE move #-} move :: forall (m :: * -> *) a. PrimMonad m => 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 => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m () {-# INLINE unsafeMove #-} unsafeMove :: forall (m :: * -> *) a. PrimMonad m => 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, Ord e) => MVector (PrimState m) e -> m Bool {-# INLINE nextPermutation #-} nextPermutation :: forall (m :: * -> *) e. (PrimMonad m, 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 => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool {-# INLINE nextPermutationBy #-} nextPermutationBy :: forall (m :: * -> *) e. PrimMonad m => (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, Ord e) => MVector (PrimState m) e -> m Bool {-# INLINE prevPermutation #-} prevPermutation :: forall (m :: * -> *) e. (PrimMonad m, 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 => (e -> e -> Ordering) -> MVector (PrimState m) e -> m Bool {-# INLINE prevPermutationBy #-} prevPermutationBy :: forall (m :: * -> *) e. PrimMonad m => (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) => (a -> m b) -> MVector (PrimState m) a -> m () {-# INLINE mapM_ #-} mapM_ :: forall (m :: * -> *) a b. PrimMonad m => (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) => (Int -> a -> m b) -> MVector (PrimState m) a -> m () {-# INLINE imapM_ #-} imapM_ :: forall (m :: * -> *) a b. PrimMonad m => (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) => MVector (PrimState m) a -> (a -> m b) -> m () {-# INLINE forM_ #-} forM_ :: forall (m :: * -> *) a b. PrimMonad m => 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) => MVector (PrimState m) a -> (Int -> a -> m b) -> m () {-# INLINE iforM_ #-} iforM_ :: forall (m :: * -> *) a b. PrimMonad m => 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) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldl #-} foldl :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldl' #-} foldl' :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldl #-} ifoldl :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> Int -> a -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldl' #-} ifoldl' :: forall (m :: * -> *) b a. PrimMonad m => (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) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldr #-} foldr :: forall (m :: * -> *) a b. PrimMonad m => (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) => (a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldr' #-} foldr' :: forall (m :: * -> *) a b. PrimMonad m => (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) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldr #-} ifoldr :: forall (m :: * -> *) a b. PrimMonad m => (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) => (Int -> a -> b -> b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldr' #-} ifoldr' :: forall (m :: * -> *) a b. PrimMonad m => (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) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldM #-} foldM :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldM' #-} foldM' :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldM #-} ifoldM :: forall (m :: * -> *) b a. PrimMonad m => (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) => (b -> Int -> a -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldM' #-} ifoldM' :: forall (m :: * -> *) b a. PrimMonad m => (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) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldrM #-} foldrM :: forall (m :: * -> *) a b. PrimMonad m => (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) => (a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE foldrM' #-} foldrM' :: forall (m :: * -> *) a b. PrimMonad m => (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) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldrM #-} ifoldrM :: forall (m :: * -> *) a b. PrimMonad m => (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) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m) a -> m b {-# INLINE ifoldrM' #-} ifoldrM' :: forall (m :: * -> *) a b. PrimMonad m => (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'

fromMutableArray :: PrimMonad m => MutableArray (PrimState m) a -> m (MVector (PrimState m) a) {-# INLINE fromMutableArray #-} fromMutableArray :: forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> m (MVector (PrimState m) a) fromMutableArray MutableArray (PrimState m) a marr = let size :: Int size = MutableArray (PrimState m) a -> Int forall s a. MutableArray s a -> Int sizeofMutableArray MutableArray (PrimState m) a marr in Int -> Int -> MutableArray (PrimState m) a -> MVector (PrimState m) a forall s a. Int -> Int -> MutableArray s a -> MVector s a MVector Int 0 Int size (MutableArray (PrimState m) a -> MVector (PrimState m) a) -> m (MutableArray (PrimState m) a) -> m (MVector (PrimState m) a) forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM MutableArray (PrimState m) a -> Int -> Int -> m (MutableArray (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> m (MutableArray (PrimState m) a) cloneMutableArray MutableArray (PrimState m) a marr Int 0 Int size

toMutableArray :: PrimMonad m => MVector (PrimState m) a -> m (MutableArray (PrimState m) a) {-# INLINE toMutableArray #-} toMutableArray :: forall (m :: * -> *) a. PrimMonad m => MVector (PrimState m) a -> m (MutableArray (PrimState m) a) toMutableArray (MVector Int offset Int size MutableArray (PrimState m) a marr) = MutableArray (PrimState m) a -> Int -> Int -> m (MutableArray (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> m (MutableArray (PrimState m) a) cloneMutableArray MutableArray (PrimState m) a marr Int offset Int size