(original) (raw)

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

module Data.Vector.Strict.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,

toLazy, fromLazy,

fromMutableArray, toMutableArray,

PrimMonad, PrimState, RealWorld ) where

import Data.Coerce import qualified Data.Vector.Generic.Mutable as G import qualified Data.Vector.Mutable as MV import Data.Primitive.Array import Control.Monad.Primitive

import Prelude ( Ord, Monad(..), Bool, Int, Maybe, Ordering(..) , return, ($), (<$>) )

import Data.Typeable ( Typeable )

#include "vector.h"

type role MVector nominal representational

newtype MVector s a = MVector (MV.MVector 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 s a -> Int) -> MVector s a -> Int forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int G.basicLength @MV.MVector @a) {-# INLINE basicUnsafeSlice #-} basicUnsafeSlice :: forall s. Int -> Int -> MVector s a -> MVector s a basicUnsafeSlice = (Int -> Int -> MVector s a -> MVector s a) -> Int -> Int -> MVector s a -> MVector s a forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a G.basicUnsafeSlice @MV.MVector @a) {-# INLINE basicOverlaps #-} basicOverlaps :: forall s. MVector s a -> MVector s a -> Bool basicOverlaps = (MVector s a -> MVector s a -> Bool) -> MVector s a -> MVector s a -> Bool forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> Bool G.basicOverlaps @MV.MVector @a) {-# INLINE basicUnsafeNew #-} basicUnsafeNew :: forall s. Int -> ST s (MVector s a) basicUnsafeNew = (Int -> ST s (MVector s a)) -> Int -> ST s (MVector s a) forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a) G.basicUnsafeNew @MV.MVector @a) {-# 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 = (Int -> a -> ST s (MVector s a)) -> Int -> a -> ST s (MVector s a) forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => Int -> a -> ST s (v s a) G.basicUnsafeReplicate @MV.MVector @a) Int n a x {-# INLINE basicUnsafeRead #-} basicUnsafeRead :: forall s. MVector s a -> Int -> ST s a basicUnsafeRead = (MVector s a -> Int -> ST s a) -> MVector s a -> Int -> ST s a forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> ST s a G.basicUnsafeRead @MV.MVector @a) {-# INLINE basicUnsafeWrite #-} basicUnsafeWrite :: forall s. MVector s a -> Int -> a -> ST s () basicUnsafeWrite MVector s a vec Int j !a x = ((MVector s a -> Int -> a -> ST s ()) -> MVector s a -> Int -> a -> ST s () forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> a -> ST s () G.basicUnsafeWrite @MV.MVector @a)) MVector s a vec Int j a x

{-# INLINE basicUnsafeCopy #-} basicUnsafeCopy :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeCopy = (MVector s a -> MVector s a -> ST s ()) -> MVector s a -> MVector s a -> ST s () forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () G.basicUnsafeCopy @MV.MVector @a)

{-# INLINE basicUnsafeMove #-} basicUnsafeMove :: forall s. MVector s a -> MVector s a -> ST s () basicUnsafeMove = (MVector s a -> MVector s a -> ST s ()) -> MVector s a -> MVector s a -> ST s () forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () G.basicUnsafeMove @MV.MVector @a) {-# INLINE basicClear #-} basicClear :: forall s. MVector s a -> ST s () basicClear = (MVector s a -> ST s ()) -> MVector s a -> ST s () forall a b. Coercible a b => a -> b coerce (forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () G.basicClear @MV.MVector @a)

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'

toLazy :: MVector s a -> MV.MVector s a {-# INLINE toLazy #-} toLazy :: forall s a. MVector s a -> MVector s a toLazy (MVector MVector s a vec) = MVector s a vec

fromLazy :: PrimMonad m => MV.MVector (PrimState m) a -> m (MVector (PrimState m) a) fromLazy :: forall (m :: * -> *) a. PrimMonad m => MVector (PrimState m) a -> m (MVector (PrimState m) a) fromLazy MVector (PrimState m) a mvec = ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a)) -> ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a) forall a b. (a -> b) -> a -> b $ do (() -> a -> ST (PrimState m) ()) -> () -> MVector (PrimState (ST (PrimState m))) a -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b G.foldM' (() _ !a _ -> () -> ST (PrimState m) () forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return ()) () MVector (PrimState m) a MVector (PrimState (ST (PrimState m))) a mvec MVector (PrimState m) a -> ST (PrimState m) (MVector (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (MVector (PrimState m) a -> ST (PrimState m) (MVector (PrimState m) a)) -> MVector (PrimState m) a -> ST (PrimState m) (MVector (PrimState m) a) forall a b. (a -> b) -> a -> b $ MVector (PrimState m) a -> MVector (PrimState m) a forall s a. MVector s a -> MVector s a MVector MVector (PrimState m) a mvec

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 = ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a)) -> ST (PrimState m) (MVector (PrimState m) a) -> m (MVector (PrimState m) a) forall a b. (a -> b) -> a -> b $ do MVector (PrimState m) a mvec <- MVector (PrimState m) a -> MVector (PrimState m) a forall s a. MVector s a -> MVector s a MVector (MVector (PrimState m) a -> MVector (PrimState m) a) -> ST (PrimState m) (MVector (PrimState m) a) -> ST (PrimState m) (MVector (PrimState m) a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> MutableArray (PrimState (ST (PrimState m))) a -> ST (PrimState m) (MVector (PrimState (ST (PrimState m))) a) forall (m :: * -> *) a. PrimMonad m => MutableArray (PrimState m) a -> m (MVector (PrimState m) a) MV.fromMutableArray MutableArray (PrimState m) a MutableArray (PrimState (ST (PrimState m))) a marr (() -> a -> ST (PrimState m) ()) -> () -> MVector (PrimState (ST (PrimState m))) a -> ST (PrimState m) () forall (m :: * -> *) b a. PrimMonad m => (b -> a -> m b) -> b -> MVector (PrimState m) a -> m b foldM' (() _ !a _ -> () -> ST (PrimState m) () forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return ()) () MVector (PrimState m) a MVector (PrimState (ST (PrimState m))) a mvec MVector (PrimState m) a -> ST (PrimState m) (MVector (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return MVector (PrimState m) a mvec

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 MVector (PrimState m) a v) = MVector (PrimState m) a -> m (MutableArray (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => MVector (PrimState m) a -> m (MutableArray (PrimState m) a) MV.toMutableArray MVector (PrimState m) a v