(original) (raw)

{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}

module Data.Vector.Generic.Mutable (

MVector(..),

length, null,

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

overlaps,

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

grow, unsafeGrow, growFront, unsafeGrowFront,

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,

mstream, mstreamR, unstream, unstreamR, vunstream, munstream, munstreamR, transform, transformR, fill, fillR, unsafeAccum, accum, unsafeUpdate, update, reverse, unstablePartition, unstablePartitionBundle, partitionBundle, partitionWithBundle,

PrimMonad, PrimState, RealWorld ) where

import Data.Vector.Generic.Mutable.Base import qualified Data.Vector.Generic.Base as V

import qualified Data.Vector.Fusion.Bundle as Bundle import Data.Vector.Fusion.Bundle ( Bundle, MBundle, Chunk(..) ) import qualified Data.Vector.Fusion.Bundle.Monadic as MBundle import Data.Vector.Fusion.Stream.Monadic ( Stream ) import qualified Data.Vector.Fusion.Stream.Monadic as Stream import Data.Vector.Fusion.Bundle.Size import Data.Vector.Fusion.Util ( delay_inline ) import Data.Vector.Internal.Check

import Control.Monad.Primitive ( PrimMonad(..), RealWorld, stToPrim )

import Prelude ( Ord, Monad, Bool(..), Int, Maybe(..), Either(..), Ordering(..) , return, otherwise, flip, const, seq, min, max, not, pure , (>>=), (+), (-), (<), (<=), (>), (>=), (==), (/=), (.), ($), (=<<), (>>), (<$>) ) import Data.Bits ( Bits(shiftR) )

#include "vector.h"

unsafeAppend1 :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) {-# INLINE_INNER unsafeAppend1 #-}

unsafeAppend1 :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) a v Int i a x | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v = do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a v | Bool otherwise = do v (PrimState m) a v' <- v (PrimState m) a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) enlarge v (PrimState m) a v Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Internal Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v') (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v' Int i a x v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a v'

unsafePrepend1 :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a, Int) {-# INLINE_INNER unsafePrepend1 #-} unsafePrepend1 :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a, Int) unsafePrepend1 v (PrimState m) a v Int i a x | Int i Int -> Int -> Bool forall a. Eq a => a -> a -> Bool /= Int 0 = do let i' :: Int i' = Int iInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1 v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i' a x (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v, Int i') | Bool otherwise = do (v (PrimState m) a v', Int j) <- v (PrimState m) a -> m (v (PrimState m) a, Int) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a, Int) enlargeFront v (PrimState m) a v let i' :: Int i' = Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1 Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Internal Int i' (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v') (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v' Int i' a x (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v', Int i')

mstream :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a {-# INLINE mstream #-} mstream :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a mstream v (PrimState m) a v = v (PrimState m) a v v (PrimState m) a -> Stream m a -> Stream m a forall a b. a -> b -> b seq Int n Int -> Stream m a -> Stream m a forall a b. a -> b -> b seq (Int -> m (Maybe (a, Int))) -> Int -> Stream m a forall (m :: * -> *) s a. Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a Stream.unfoldrM Int -> m (Maybe (a, Int)) get Int 0 where n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

{-# INLINE_INNER get #-}
get :: Int -> m (Maybe (a, Int))

get Int i | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int n = do a x <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i Maybe (a, Int) -> m (Maybe (a, Int)) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (a, Int) -> m (Maybe (a, Int))) -> Maybe (a, Int) -> m (Maybe (a, Int)) forall a b. (a -> b) -> a -> b $ (a, Int) -> Maybe (a, Int) forall a. a -> Maybe a Just (a x, Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1) | Bool otherwise = Maybe (a, Int) -> m (Maybe (a, Int)) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (a, Int) forall a. Maybe a Nothing

fill :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) {-# INLINE fill #-} fill :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) fill v (PrimState m) a v Stream m a s = v (PrimState m) a v v (PrimState m) a -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. a -> b -> b seq do Int n' <- (Int -> a -> m Int) -> Int -> Stream m a -> m Int forall (m :: * -> *) a b. Monad m => (a -> b -> m a) -> a -> Stream m b -> m a Stream.foldM Int -> a -> m Int put Int 0 Stream m a s v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n' v (PrimState m) a v where {-# INLINE_INNER put #-} put :: Int -> a -> m Int put Int i a x = do Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Internal Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1)

transform :: (PrimMonad m, MVector v a) => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) {-# INLINE_FUSED transform #-} transform :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) transform Stream m a -> Stream m a f v (PrimState m) a v = v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) fill v (PrimState m) a v (Stream m a -> Stream m a f (v (PrimState m) a -> Stream m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a mstream v (PrimState m) a v))

mstreamR :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a {-# INLINE mstreamR #-} mstreamR :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a mstreamR v (PrimState m) a v = v (PrimState m) a v v (PrimState m) a -> Stream m a -> Stream m a forall a b. a -> b -> b seq Int n Int -> Stream m a -> Stream m a forall a b. a -> b -> b seq (Int -> m (Maybe (a, Int))) -> Int -> Stream m a forall (m :: * -> *) s a. Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a Stream.unfoldrM Int -> m (Maybe (a, Int)) get Int n where n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

{-# INLINE_INNER get #-}
get :: Int -> m (Maybe (a, Int))

get Int i | Int j Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

= Int 0 = do a x <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int j Maybe (a, Int) -> m (Maybe (a, Int)) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (a, Int) -> m (Maybe (a, Int))) -> Maybe (a, Int) -> m (Maybe (a, Int)) forall a b. (a -> b) -> a -> b $ (a, Int) -> Maybe (a, Int) forall a. a -> Maybe a Just (a x,Int j) | Bool otherwise = Maybe (a, Int) -> m (Maybe (a, Int)) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (a, Int) forall a. Maybe a Nothing where j :: Int j = Int iInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1

fillR :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) {-# INLINE fillR #-} fillR :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) fillR v (PrimState m) a v Stream m a s = v (PrimState m) a v v (PrimState m) a -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. a -> b -> b seq do Int i <- (Int -> a -> m Int) -> Int -> Stream m a -> m Int forall (m :: * -> *) a b. Monad m => (a -> b -> m a) -> a -> Stream m b -> m a Stream.foldM Int -> a -> m Int put Int n Stream m a s v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int i (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i) v (PrimState m) a v where n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

{-# INLINE_INNER put #-}
put :: Int -> a -> m Int

put Int i a x = do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int j a x Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Int j where j :: Int j = Int iInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1

transformR :: (PrimMonad m, MVector v a) => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) {-# INLINE_FUSED transformR #-} transformR :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) transformR Stream m a -> Stream m a f v (PrimState m) a v = v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) fillR v (PrimState m) a v (Stream m a -> Stream m a f (v (PrimState m) a -> Stream m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a mstreamR v (PrimState m) a v))

unstream :: (PrimMonad m, MVector v a) => Bundle u a -> m (v (PrimState m) a)

{-# INLINE_FUSED unstream #-} unstream :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => Bundle u a -> m (v (PrimState m) a) unstream Bundle u a s = MBundle m u a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstream (Bundle u a -> MBundle m u a forall (m :: * -> *) (v :: * -> *) a. Monad m => Bundle Id v a -> Bundle m v a Bundle.lift Bundle u a s)

munstream :: (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) {-# INLINE_FUSED munstream #-} munstream :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstream MBundle m u a s = case Size -> Maybe Int upperBound (MBundle m u a -> Size forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size MBundle.size MBundle m u a s) of Just Int n -> MBundle m u a -> Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) munstreamMax MBundle m u a s Int n Maybe Int Nothing -> MBundle m u a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamUnknown MBundle m u a s

munstreamMax :: (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) {-# INLINE munstreamMax #-} munstreamMax :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) munstreamMax MBundle m u a s Int n = do v (PrimState m) a v <- Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Internal Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n let put :: Int -> a -> m Int put Int i a x = do Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Internal Int i Int n (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1) Int n' <- (Int -> a -> m Int) -> Int -> MBundle m u a -> m Int forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a MBundle.foldM' Int -> a -> m Int put Int 0 MBundle m u a s v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n' Int n (v (PrimState m) a -> v (PrimState m) a) -> v (PrimState m) a -> v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n' v (PrimState m) a v

munstreamUnknown :: (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) {-# INLINE munstreamUnknown #-} munstreamUnknown :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamUnknown MBundle m u a s = do v (PrimState m) a v <- Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 (v (PrimState m) a v', Int n) <- ((v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int)) -> (v (PrimState m) a, Int) -> MBundle m u a -> m (v (PrimState m) a, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a MBundle.foldM (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) forall {m :: * -> *} {v :: * -> * -> *} {a}. (PrimMonad m, MVector v a) => (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) put (v (PrimState m) a v, Int 0) MBundle m u a s v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v') (v (PrimState m) a -> v (PrimState m) a) -> v (PrimState m) a -> v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n v (PrimState m) a v' where {-# INLINE_INNER put #-} put :: (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) put (v (PrimState m) a v,Int i) a x = do v (PrimState m) a v' <- v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) a v Int i a x (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v',Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1)

vunstream :: (PrimMonad m, V.Vector v a) => Bundle v a -> m (V.Mutable v (PrimState m) a)

{-# INLINE_FUSED vunstream #-} vunstream :: forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => Bundle v a -> m (Mutable v (PrimState m) a) vunstream Bundle v a s = MBundle m v a -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> m (Mutable v (PrimState m) a) vmunstream (Bundle v a -> MBundle m v a forall (m :: * -> *) (v :: * -> *) a. Monad m => Bundle Id v a -> Bundle m v a Bundle.lift Bundle v a s)

vmunstream :: (PrimMonad m, V.Vector v a) => MBundle m v a -> m (V.Mutable v (PrimState m) a) {-# INLINE_FUSED vmunstream #-} vmunstream :: forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> m (Mutable v (PrimState m) a) vmunstream MBundle m v a s = case Size -> Maybe Int upperBound (MBundle m v a -> Size forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size MBundle.size MBundle m v a s) of Just Int n -> MBundle m v a -> Int -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> Int -> m (Mutable v (PrimState m) a) vmunstreamMax MBundle m v a s Int n Maybe Int Nothing -> MBundle m v a -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> m (Mutable v (PrimState m) a) vmunstreamUnknown MBundle m v a s

vmunstreamMax :: (PrimMonad m, V.Vector v a) => MBundle m v a -> Int -> m (V.Mutable v (PrimState m) a) {-# INLINE vmunstreamMax #-} vmunstreamMax :: forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> Int -> m (Mutable v (PrimState m) a) vmunstreamMax MBundle m v a s Int n = do Mutable v (PrimState m) a v <- Checks -> Int -> m (Mutable v (PrimState m) a) -> m (Mutable v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Internal Int n (m (Mutable v (PrimState m) a) -> m (Mutable v (PrimState m) a)) -> m (Mutable v (PrimState m) a) -> m (Mutable v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n let {-# INLINE_INNER copyChunk #-} copyChunk :: Int -> Chunk v a -> m Int copyChunk Int i (Chunk Int m forall (m :: * -> *). (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m () f) = Checks -> Int -> Int -> Int -> m Int -> m Int forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int i Int m (Mutable v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length Mutable v (PrimState m) a v) (m Int -> m Int) -> m Int -> m Int forall a b. (a -> b) -> a -> b $ do Mutable v (PrimState m) a -> m () forall (m :: * -> *). (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m () f (Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall s. Int -> Int -> Mutable v s a -> Mutable v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int i Int m Mutable v (PrimState m) a v) Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int m)

  Int

n' <- (Int -> Chunk v a -> m Int) -> Int -> Stream m (Chunk v a) -> m Int forall (m :: * -> *) a b. Monad m => (a -> b -> m a) -> a -> Stream m b -> m a Stream.foldlM' Int -> Chunk v a -> m Int copyChunk Int 0 (MBundle m v a -> Stream m (Chunk v a) forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m (Chunk v a) MBundle.chunks MBundle m v a s) Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a)) -> Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n' Int n (Mutable v (PrimState m) a -> Mutable v (PrimState m) a) -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n' Mutable v (PrimState m) a v

vmunstreamUnknown :: (PrimMonad m, V.Vector v a) => MBundle m v a -> m (V.Mutable v (PrimState m) a) {-# INLINE vmunstreamUnknown #-} vmunstreamUnknown :: forall (m :: * -> *) (v :: * -> *) a. (PrimMonad m, Vector v a) => MBundle m v a -> m (Mutable v (PrimState m) a) vmunstreamUnknown MBundle m v a s = do Mutable v (PrimState m) a v <- Int -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 (Mutable v (PrimState m) a v', Int n) <- ((Mutable v (PrimState m) a, Int) -> Chunk v a -> m (Mutable v (PrimState m) a, Int)) -> (Mutable v (PrimState m) a, Int) -> Stream m (Chunk v a) -> m (Mutable v (PrimState m) a, Int) forall (m :: * -> *) a b. Monad m => (a -> b -> m a) -> a -> Stream m b -> m a Stream.foldlM (Mutable v (PrimState m) a, Int) -> Chunk v a -> m (Mutable v (PrimState m) a, Int) forall {m :: * -> *} {v :: * -> *} {a}. (PrimMonad m, Vector v a) => (Mutable v (PrimState m) a, Int) -> Chunk v a -> m (Mutable v (PrimState m) a, Int) copyChunk (Mutable v (PrimState m) a v,Int 0) (MBundle m v a -> Stream m (Chunk v a) forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m (Chunk v a) MBundle.chunks MBundle m v a s) Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a)) -> Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n (Mutable v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length Mutable v (PrimState m) a v') (Mutable v (PrimState m) a -> Mutable v (PrimState m) a) -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n Mutable v (PrimState m) a v' where {-# INLINE_INNER copyChunk #-} copyChunk :: (Mutable v (PrimState m) a, Int) -> Chunk v a -> m (Mutable v (PrimState m) a, Int) copyChunk (Mutable v (PrimState m) a v,Int i) (Chunk Int n forall (m :: * -> *). (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m () f) = do let j :: Int j = Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int n Mutable v (PrimState m) a v' <- if Mutable v (PrimState m) a -> Int forall s. Mutable v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int basicLength Mutable v (PrimState m) a v Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int j then Mutable v (PrimState m) a -> Int -> m (Mutable v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrow Mutable v (PrimState m) a v ((Int -> Int -> Int) -> Int -> Int -> Int forall a b. (a -> b) -> a -> b delay_inline Int -> Int -> Int forall a. Ord a => a -> a -> a max (Mutable v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int enlarge_delta Mutable v (PrimState m) a v) (Int j Int -> Int -> Int forall a. Num a => a -> a -> a

• Mutable v (PrimState m) a -> Int forall s. Mutable v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int basicLength Mutable v (PrimState m) a v)) else Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a)

forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Mutable v (PrimState m) a v Checks -> Int -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int i Int n (Mutable v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length Mutable v (PrimState m) a v') (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Mutable v (PrimState m) a -> m () forall (m :: * -> *). (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m () f (Int -> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a forall s. Int -> Int -> Mutable v s a -> Mutable v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int i Int n Mutable v (PrimState m) a v') (Mutable v (PrimState m) a, Int) -> m (Mutable v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Mutable v (PrimState m) a v',Int j)

unstreamR :: (PrimMonad m, MVector v a) => Bundle u a -> m (v (PrimState m) a)

{-# INLINE_FUSED unstreamR #-} unstreamR :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => Bundle u a -> m (v (PrimState m) a) unstreamR Bundle u a s = MBundle m u a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamR (Bundle u a -> MBundle m u a forall (m :: * -> *) (v :: * -> *) a. Monad m => Bundle Id v a -> Bundle m v a Bundle.lift Bundle u a s)

munstreamR :: (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) {-# INLINE_FUSED munstreamR #-} munstreamR :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamR MBundle m u a s = case Size -> Maybe Int upperBound (MBundle m u a -> Size forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size MBundle.size MBundle m u a s) of Just Int n -> MBundle m u a -> Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) munstreamRMax MBundle m u a s Int n Maybe Int Nothing -> MBundle m u a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (HasCallStack, PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamRUnknown MBundle m u a s

munstreamRMax :: (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) {-# INLINE munstreamRMax #-} munstreamRMax :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> Int -> m (v (PrimState m) a) munstreamRMax MBundle m u a s Int n = do v (PrimState m) a v <- Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Internal Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n let put :: Int -> a -> m Int put Int i a x = do let i' :: Int i' = Int iInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1 Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Internal Int i' Int n (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i' a x Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Int i' Int i <- (Int -> a -> m Int) -> Int -> MBundle m u a -> m Int forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a MBundle.foldM' Int -> a -> m Int put Int n MBundle m u a s v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int i (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i) Int n (v (PrimState m) a -> v (PrimState m) a) -> v (PrimState m) a -> v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int i (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i) v (PrimState m) a v

munstreamRUnknown :: (HasCallStack, PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) {-# INLINE munstreamRUnknown #-} munstreamRUnknown :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (HasCallStack, PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstreamRUnknown MBundle m u a s = do v (PrimState m) a v <- Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 (v (PrimState m) a v', Int i) <- ((v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int)) -> (v (PrimState m) a, Int) -> MBundle m u a -> m (v (PrimState m) a, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a MBundle.foldM (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) forall {m :: * -> *} {v :: * -> * -> *} {a}. (PrimMonad m, MVector v a) => (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) put (v (PrimState m) a v, Int 0) MBundle m u a s let n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v' v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a -> m (v (PrimState m) a)) -> v (PrimState m) a -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int i (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i) Int n (v (PrimState m) a -> v (PrimState m) a) -> v (PrimState m) a -> v (PrimState m) a forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int i (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int i) v (PrimState m) a v' where {-# INLINE_INNER put #-} put :: (v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int) put (v (PrimState m) a v,Int i) a x = v (PrimState m) a -> Int -> a -> m (v (PrimState m) a, Int) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a, Int) unsafePrepend1 v (PrimState m) a v Int i a x

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

null :: MVector v a => v s a -> Bool {-# INLINE null #-} null :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> Bool null v s a v = v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == Int 0

slice :: (HasCallStack, MVector v a) => Int
-> Int
-> v s a -> v s a {-# INLINE slice #-} slice :: forall (v :: * -> * -> *) a s. (HasCallStack, MVector v a) => Int -> Int -> v s a -> v s a slice Int i Int n v s a v = Checks -> Int -> Int -> Int -> v s a -> v s a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Bounds Int i Int n (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v) (v s a -> v s a) -> v s a -> v s a forall a b. (a -> b) -> a -> b $ Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int i Int n v s a v

take :: MVector v a => Int -> v s a -> v s a {-# INLINE take #-} take :: forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a take Int n v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 (Int -> Int -> Int forall a. Ord a => a -> a -> a min (Int -> Int -> Int forall a. Ord a => a -> a -> a max Int n Int 0) (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v)) v s a v

drop :: MVector v a => Int -> v s a -> v s a {-# INLINE drop #-} drop :: forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a drop Int n v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice (Int -> Int -> Int forall a. Ord a => a -> a -> a min Int m Int n') (Int -> Int -> Int forall a. Ord a => a -> a -> a max Int 0 (Int m Int -> Int -> Int forall a. Num a => a -> a -> a

• Int n')) v s a v where n' :: Int n' = Int -> Int -> Int forall a. Ord a => a -> a -> a max Int n Int 0 m :: Int m = v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v

splitAt :: MVector v a => Int -> v s a -> (v s a, v s a) {-# INLINE splitAt #-} splitAt :: forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> (v s a, v s a) splitAt Int n v s a v = ( Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int m v s a v , Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int m (Int -> Int -> Int forall a. Ord a => a -> a -> a max Int 0 (Int len Int -> Int -> Int forall a. Num a => a -> a -> a

• Int n')) v s a v ) where m :: Int

m = Int -> Int -> Int forall a. Ord a => a -> a -> a min Int n' Int len n' :: Int n' = Int -> Int -> Int forall a. Ord a => a -> a -> a max Int n Int 0 len :: Int len = v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v

init :: MVector v a => v s a -> v s a {-# INLINE init #-} init :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a init v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. (HasCallStack, MVector v a) => Int -> Int -> v s a -> v s a slice Int 0 (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. v s a v

tail :: MVector v a => v s a -> v s a {-# INLINE tail #-} tail :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a tail v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. (HasCallStack, MVector v a) => Int -> Int -> v s a -> v s a slice Int 1 (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. v s a v

unsafeSlice :: MVector v a => Int
-> Int
-> v s a -> v s a {-# INLINE unsafeSlice #-}

unsafeSlice :: forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice !Int i !Int n v s a v = Checks -> Int -> Int -> Int -> v s a -> v s a forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Unsafe Int i Int n (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v) (v s a -> v s a) -> v s a -> v s a forall a b. (a -> b) -> a -> b $ Int -> Int -> v s a -> v s a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int i Int n v s a v

unsafeInit :: MVector v a => v s a -> v s a {-# INLINE unsafeInit #-} unsafeInit :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a unsafeInit v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. v s a v

unsafeTail :: MVector v a => v s a -> v s a {-# INLINE unsafeTail #-} unsafeTail :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a unsafeTail v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 1 (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. v s a v

unsafeTake :: MVector v a => Int -> v s a -> v s a {-# INLINE unsafeTake #-} unsafeTake :: forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a unsafeTake Int n v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n v s a v

unsafeDrop :: MVector v a => Int -> v s a -> v s a {-# INLINE unsafeDrop #-} unsafeDrop :: forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a unsafeDrop Int n v s a v = Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int n (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int n) v s a v

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

new :: (HasCallStack, PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) {-# INLINE new #-} new :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) new Int n = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Bounds Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n ST (PrimState m) (v (PrimState m) a) -> (v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) forall a b. ST (PrimState m) a -> (a -> ST (PrimState m) b) -> ST (PrimState m) b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= \v (PrimState m) a v -> v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicInitialize v (PrimState m) a v ST (PrimState m) () -> ST (PrimState m) (v (PrimState m) a) -> ST (PrimState m) (v (PrimState m) a) forall a b. ST (PrimState m) a -> ST (PrimState m) b -> ST (PrimState m) b forall (m :: * -> *) a b. Monad m => m a -> m b -> m b v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a v

unsafeNew :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) {-# INLINE unsafeNew #-} unsafeNew :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Unsafe Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> ST (PrimState m) (v (PrimState m) a) forall s. Int -> ST s (v s a) forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a) basicUnsafeNew Int n

replicate :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a) {-# INLINE replicate #-} replicate :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a) replicate Int n a x = ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> a -> ST (PrimState m) (v (PrimState m) a) forall s. Int -> a -> ST s (v s a) forall (v :: * -> * -> *) a s. MVector v a => Int -> a -> ST s (v s a) basicUnsafeReplicate ((Int -> Int -> Int) -> Int -> Int -> Int forall a b. (a -> b) -> a -> b delay_inline Int -> Int -> Int forall a. Ord a => a -> a -> a max Int 0 Int n) a x

replicateM :: (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a) {-# INLINE replicateM #-} replicateM :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a) replicateM Int n m a m = MBundle m Any a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstream (Int -> m a -> MBundle m Any a forall (m :: * -> *) a (v :: * -> *). Monad m => Int -> m a -> Bundle m v a MBundle.replicateM Int n m a m)

generate :: (PrimMonad m, MVector v a) => Int -> (Int -> a) -> m (v (PrimState m) a) {-# INLINE generate #-} generate :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> (Int -> a) -> m (v (PrimState m) a) generate Int n Int -> a f = ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> (Int -> ST (PrimState m) a) -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> (Int -> m a) -> m (v (PrimState m) a) generateM Int n (a -> ST (PrimState m) a forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (a -> ST (PrimState m) a) -> (Int -> a) -> Int -> ST (PrimState m) a forall b c a. (b -> c) -> (a -> b) -> a -> c . Int -> a f)

generateM :: (PrimMonad m, MVector v a) => Int -> (Int -> m a) -> m (v (PrimState m) a) {-# INLINE generateM #-} generateM :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> (Int -> m a) -> m (v (PrimState m) a) generateM Int n Int -> m a f = MBundle m Any a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => MBundle m u a -> m (v (PrimState m) a) munstream (Int -> (Int -> m a) -> MBundle m Any a forall (m :: * -> *) a (v :: * -> *). Monad m => Int -> (Int -> m a) -> Bundle m v a MBundle.generateM Int n Int -> m a f)

clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) {-# INLINE clone #-} clone :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) clone v (PrimState m) a v = do v (PrimState m) a v' <- Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) v (PrimState m) a -> v (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () unsafeCopy v (PrimState m) a v' v (PrimState m) a v v (PrimState m) a -> m (v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a v'

grow :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) {-# INLINE grow #-} grow :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) grow v (PrimState m) a v Int by = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Bounds Int by (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ do v (PrimState m) a vnew <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrow v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int by v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicInitialize (v (PrimState m) a -> ST (PrimState m) ()) -> v (PrimState m) a -> ST (PrimState m) () forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) Int by v (PrimState m) a vnew v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a vnew

growFront :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) {-# INLINE growFront #-} growFront :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) growFront v (PrimState m) a v Int by = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Bounds Int by (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ do v (PrimState m) a vnew <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrowFront v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int by v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicInitialize (v (PrimState m) a -> ST (PrimState m) ()) -> v (PrimState m) a -> ST (PrimState m) () forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int 0 Int by v (PrimState m) a vnew v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a vnew

enlarge_delta :: MVector v a => v s a -> Int enlarge_delta :: forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int enlarge_delta v s a v = Int -> Int -> Int forall a. Ord a => a -> a -> a max (v s a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v s a v) Int 1

enlarge :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) {-# INLINE enlarge #-} enlarge :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) enlarge v (PrimState m) a v = ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ do v (PrimState m) a vnew <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrow v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int by v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicInitialize (v (PrimState m) a -> ST (PrimState m) ()) -> v (PrimState m) a -> ST (PrimState m) () forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) Int by v (PrimState m) a vnew v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a vnew where by :: Int by = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int enlarge_delta v (PrimState m) a v

enlargeFront :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a, Int) {-# INLINE enlargeFront #-} enlargeFront :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a, Int) enlargeFront v (PrimState m) a v = ST (PrimState m) (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int)) -> ST (PrimState m) (v (PrimState m) a, Int) -> m (v (PrimState m) a, Int) forall a b. (a -> b) -> a -> b $ do v (PrimState m) a v' <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) (v (PrimState (ST (PrimState m))) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrowFront v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int by v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicInitialize (v (PrimState m) a -> ST (PrimState m) ()) -> v (PrimState m) a -> ST (PrimState m) () forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int 0 Int by v (PrimState m) a v' (v (PrimState m) a, Int) -> ST (PrimState m) (v (PrimState m) a, Int) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v', Int by) where by :: Int by = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int enlarge_delta v (PrimState m) a v

unsafeGrow :: (PrimMonad m, MVector v a) => v (PrimState m) a

-> Int

-> m (v (PrimState m) a) {-# INLINE unsafeGrow #-} unsafeGrow :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrow v (PrimState m) a v Int n = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Unsafe Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> ST (PrimState m) (v (PrimState m) a) forall s. v s a -> Int -> ST s (v s a) forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> ST s (v s a) basicUnsafeGrow v (PrimState m) a v Int n

unsafeGrowFront :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) {-# INLINE unsafeGrowFront #-} unsafeGrowFront :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (v (PrimState m) a) unsafeGrowFront v (PrimState m) a v Int by = Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Unsafe Int by (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a)) -> ST (PrimState m) (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ do let n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v v (PrimState m) a v' <- Int -> ST (PrimState m) (v (PrimState m) a) forall s. Int -> ST s (v s a) forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a) basicUnsafeNew (Int byInt -> Int -> Int forall a. Num a => a -> a -> a +Int n) v (PrimState m) a -> v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () basicUnsafeCopy (Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall s. Int -> Int -> v s a -> v s a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a basicUnsafeSlice Int by Int n v (PrimState m) a v') v (PrimState m) a v v (PrimState m) a -> ST (PrimState m) (v (PrimState m) a) forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return v (PrimState m) a v'

clear :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m () {-# INLINE clear #-} clear :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m () clear = ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> (v (PrimState m) a -> ST (PrimState m) ()) -> v (PrimState m) a -> m () forall b c a. (b -> c) -> (a -> b) -> a -> c . v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s () basicClear

read :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a {-# INLINE read #-} read :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a read v (PrimState m) a v Int i = Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i

readMaybe :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (Maybe a) {-# INLINE readMaybe #-} readMaybe :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m (Maybe a) readMaybe v (PrimState m) a v Int i | Int i Int -> Int -> Bool inRange (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) = a -> Maybe a forall a. a -> Maybe a Just (a -> Maybe a) -> m a -> m (Maybe a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i | Bool otherwise = Maybe a -> m (Maybe a) forall a. a -> m a forall (f :: * -> *) a. Applicative f => a -> f a pure Maybe a forall a. Maybe a Nothing

write :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () {-# INLINE write #-} write :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () write v (PrimState m) a v Int i a x = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x

modify :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE modify #-} modify :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () modify v (PrimState m) a v a -> a f Int i = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> (a -> a) -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () unsafeModify v (PrimState m) a v a -> a f Int i

modifyM :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE modifyM #-} modifyM :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () modifyM v (PrimState m) a v a -> m a f Int i = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (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 () unsafeModifyM v (PrimState m) a v a -> m a f Int i

swap :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () {-# INLINE swap #-} swap :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () swap v (PrimState m) a v Int i Int j = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int j (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> Int -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () unsafeSwap v (PrimState m) a v Int i Int j

exchange :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a {-# INLINE exchange #-} exchange :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a exchange v (PrimState m) a v Int i a x = Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a unsafeExchange v (PrimState m) a v Int i a x

unsafeRead :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a {-# INLINE unsafeRead #-}

unsafeRead :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v !Int i = Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ ST (PrimState m) a -> m a forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) a -> m a) -> ST (PrimState m) a -> m a forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> ST (PrimState m) a forall s. v s a -> Int -> ST s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> ST s a basicUnsafeRead v (PrimState m) a v Int i

unsafeWrite :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () {-# INLINE unsafeWrite #-}

unsafeWrite :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v !Int i a x = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> ST (PrimState m) () forall s. v s a -> Int -> a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> a -> ST s () basicUnsafeWrite v (PrimState m) a v Int i a x

unsafeModify :: (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () {-# INLINE unsafeModify #-}

unsafeModify :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> a) -> Int -> m () unsafeModify v (PrimState m) a v a -> a f !Int i = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> ST (PrimState m) a forall s. v s a -> Int -> ST s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> ST s a basicUnsafeRead v (PrimState m) a v Int i ST (PrimState m) a -> (a -> ST (PrimState m) ()) -> ST (PrimState m) () forall a b. ST (PrimState m) a -> (a -> ST (PrimState m) b) -> ST (PrimState m) b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= \a x -> v (PrimState m) a -> Int -> a -> ST (PrimState m) () forall s. v s a -> Int -> a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> a -> ST s () basicUnsafeWrite v (PrimState m) a v Int i (a -> a f a x)

unsafeModifyM :: (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () {-# INLINE unsafeModifyM #-}

unsafeModifyM :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> (a -> m a) -> Int -> m () unsafeModifyM v (PrimState m) a v a -> m a f !Int i = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> (a -> ST (PrimState m) ()) -> a -> m () forall b c a. (b -> c) -> (a -> b) -> a -> c . v (PrimState m) a -> Int -> a -> ST (PrimState m) () forall s. v s a -> Int -> a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> a -> ST s () basicUnsafeWrite v (PrimState m) a v Int i (a -> m ()) -> m a -> m () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< a -> m a f (a -> m a) -> m a -> m a forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< ST (PrimState m) a -> m a forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (v (PrimState m) a -> Int -> ST (PrimState m) a forall s. v s a -> Int -> ST s a forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> ST s a basicUnsafeRead v (PrimState m) a v Int i)

unsafeSwap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () {-# INLINE unsafeSwap #-} unsafeSwap :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () unsafeSwap v (PrimState m) a v Int i Int j = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int j (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m () forall a b. (a -> b) -> a -> b $ do a x <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int i a y <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int j v (PrimState (ST (PrimState m))) a -> Int -> a -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int i a y v (PrimState (ST (PrimState m))) a -> Int -> a -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int j a x

unsafeExchange :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a {-# INLINE unsafeExchange #-} unsafeExchange :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m a unsafeExchange v (PrimState m) a v Int i a x = Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ ST (PrimState m) a -> m a forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) a -> m a) -> ST (PrimState m) a -> m a forall a b. (a -> b) -> a -> b $ do a y <- v (PrimState (ST (PrimState m))) a -> Int -> ST (PrimState m) a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int i v (PrimState (ST (PrimState m))) a -> Int -> a -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v (PrimState (ST (PrimState m))) a v Int i a x a -> ST (PrimState m) a forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return a y

forI_ :: (Monad m, MVector v a) => v (PrimState m) a -> (Int -> m b) -> m () {-# INLINE forI_ #-} forI_ :: forall (m :: * -> *) (v :: * -> * -> *) a b. (Monad m, MVector v a) => v (PrimState m) a -> (Int -> m b) -> m () forI_ v (PrimState m) a v Int -> m b f = Int -> m () loop Int 0 where loop :: Int -> m () loop Int i | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

= Int n = () -> m () forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return () | Bool otherwise = Int -> m b f Int i m b -> 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 () loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

mapM_ :: (PrimMonad m, MVector v a) => (a -> m b) -> v (PrimState m) a -> m () {-# INLINE mapM_ #-} mapM_ :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> m b) -> v (PrimState m) a -> m () mapM_ a -> m b f v (PrimState m) a v = v (PrimState m) a -> (Int -> m b) -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (Monad m, MVector v a) => v (PrimState m) a -> (Int -> m b) -> m () forI_ v (PrimState m) a v ((Int -> m b) -> m ()) -> (Int -> m b) -> m () forall a b. (a -> b) -> a -> b $ \Int i -> a -> m b f (a -> m b) -> m a -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i

imapM_ :: (PrimMonad m, MVector v a) => (Int -> a -> m b) -> v (PrimState m) a -> m () {-# INLINE imapM_ #-} imapM_ :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> m b) -> v (PrimState m) a -> m () imapM_ Int -> a -> m b f v (PrimState m) a v = v (PrimState m) a -> (Int -> m b) -> m () forall (m :: * -> *) (v :: * -> * -> *) a b. (Monad m, MVector v a) => v (PrimState m) a -> (Int -> m b) -> m () forI_ v (PrimState m) a v ((Int -> m b) -> m ()) -> (Int -> m b) -> m () forall a b. (a -> b) -> a -> b $ \Int i -> Int -> a -> m b f Int i (a -> m b) -> m a -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i

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

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

foldl :: (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b {-# INLINE foldl #-} foldl :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b foldl b -> a -> b f = (b -> Int -> a -> b) -> b -> v (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 ifoldl (\b b Int _ -> b -> a -> b f b b)

foldl' :: (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b {-# INLINE foldl' #-} foldl' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> b) -> b -> v (PrimState m) a -> m b foldl' b -> a -> b f = (b -> Int -> a -> b) -> b -> v (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 ifoldl' (\b b Int _ -> b -> a -> b f b b)

ifoldl :: (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldl #-} ifoldl :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b ifoldl b -> Int -> a -> b f b b0 v (PrimState m) a v = ST (PrimState m) b -> m b forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) b -> m b) -> ST (PrimState m) b -> m b forall a b. (a -> b) -> a -> b $ (b -> Int -> a -> ST (PrimState m) b) -> b -> v (PrimState (ST (PrimState m))) a -> ST (PrimState m) b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b ifoldM (\b b Int i a a -> b -> ST (PrimState m) b forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (b -> ST (PrimState m) b) -> b -> ST (PrimState m) b forall a b. (a -> b) -> a -> b $ b -> Int -> a -> b f b b Int i a a) b b0 v (PrimState m) a v (PrimState (ST (PrimState m))) a v

ifoldl' :: (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldl' #-} ifoldl' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> b) -> b -> v (PrimState m) a -> m b ifoldl' b -> Int -> a -> b f b b0 v (PrimState m) a v = ST (PrimState m) b -> m b forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) b -> m b) -> ST (PrimState m) b -> m b forall a b. (a -> b) -> a -> b $ (b -> Int -> a -> ST (PrimState m) b) -> b -> v (PrimState (ST (PrimState m))) a -> ST (PrimState m) b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b ifoldM' (\b b Int i a a -> b -> ST (PrimState m) b forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (b -> ST (PrimState m) b) -> b -> ST (PrimState m) b forall a b. (a -> b) -> a -> b $ b -> Int -> a -> b f b b Int i a a) b b0 v (PrimState m) a v (PrimState (ST (PrimState m))) a v

foldr :: (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b {-# INLINE foldr #-} foldr :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b foldr a -> b -> b f = (Int -> a -> b -> b) -> b -> v (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 ifoldr ((a -> b -> b) -> Int -> a -> b -> b forall a b. a -> b -> a const a -> b -> b f)

foldr' :: (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b {-# INLINE foldr' #-} foldr' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> b) -> b -> v (PrimState m) a -> m b foldr' a -> b -> b f = (Int -> a -> b -> b) -> b -> v (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 ifoldr' ((a -> b -> b) -> Int -> a -> b -> b forall a b. a -> b -> a const a -> b -> b f)

ifoldr :: (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldr #-} ifoldr :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b ifoldr Int -> a -> b -> b f b b0 v (PrimState m) a v = ST (PrimState m) b -> m b forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) b -> m b) -> ST (PrimState m) b -> m b forall a b. (a -> b) -> a -> b $ (Int -> a -> b -> ST (PrimState m) b) -> b -> v (PrimState (ST (PrimState m))) a -> ST (PrimState m) b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b ifoldrM (\Int i a a b b -> b -> ST (PrimState m) b forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (b -> ST (PrimState m) b) -> b -> ST (PrimState m) b forall a b. (a -> b) -> a -> b $ Int -> a -> b -> b f Int i a a b b) b b0 v (PrimState m) a v (PrimState (ST (PrimState m))) a v

ifoldr' :: (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldr' #-} ifoldr' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> b) -> b -> v (PrimState m) a -> m b ifoldr' Int -> a -> b -> b f b b0 v (PrimState m) a v = ST (PrimState m) b -> m b forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) b -> m b) -> ST (PrimState m) b -> m b forall a b. (a -> b) -> a -> b $ (Int -> a -> b -> ST (PrimState m) b) -> b -> v (PrimState (ST (PrimState m))) a -> ST (PrimState m) b forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b ifoldrM' (\Int i a a b b -> b -> ST (PrimState m) b forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return (b -> ST (PrimState m) b) -> b -> ST (PrimState m) b forall a b. (a -> b) -> a -> b $ Int -> a -> b -> b f Int i a a b b) b b0 v (PrimState m) a v (PrimState (ST (PrimState m))) a v

foldM :: (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE foldM #-} foldM :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b foldM b -> a -> m b f = (b -> Int -> a -> m b) -> b -> v (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 ifoldM (\b x Int _ -> b -> a -> m b f b x)

foldM' :: (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE foldM' #-} foldM' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> a -> m b) -> b -> v (PrimState m) a -> m b foldM' b -> a -> m b f = (b -> Int -> a -> m b) -> b -> v (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 ifoldM' (\b x Int _ -> b -> a -> m b f b x)

ifoldM :: (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldM #-} ifoldM :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b ifoldM b -> Int -> a -> m b f b b0 v (PrimState m) a v = Int -> b -> m b loop Int 0 b b0 where loop :: Int -> b -> m b loop Int i b b | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

= Int n = b -> m b forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return b b | Bool otherwise = do a a <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i Int -> b -> m b loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (b -> m b) -> m b -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< b -> Int -> a -> m b f b b Int i a a n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

ifoldM' :: (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldM' #-} ifoldM' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (b -> Int -> a -> m b) -> b -> v (PrimState m) a -> m b ifoldM' b -> Int -> a -> m b f b b0 v (PrimState m) a v = Int -> b -> m b loop Int 0 b b0 where loop :: Int -> b -> m b loop Int i !b b | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

= Int n = b -> m b forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return b b | Bool otherwise = do a a <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i Int -> b -> m b loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (b -> m b) -> m b -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< b -> Int -> a -> m b f b b Int i a a n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

foldrM :: (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE foldrM #-} foldrM :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b foldrM a -> b -> m b f = (Int -> a -> b -> m b) -> b -> v (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 ifoldrM ((a -> b -> m b) -> Int -> a -> b -> m b forall a b. a -> b -> a const a -> b -> m b f)

foldrM' :: (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE foldrM' #-} foldrM' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (a -> b -> m b) -> b -> v (PrimState m) a -> m b foldrM' a -> b -> m b f = (Int -> a -> b -> m b) -> b -> v (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 ifoldrM' ((a -> b -> m b) -> Int -> a -> b -> m b forall a b. a -> b -> a const a -> b -> m b f)

ifoldrM :: (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldrM #-} ifoldrM :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b ifoldrM Int -> a -> b -> m b f b b0 v (PrimState m) a v = Int -> b -> m b loop (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int

1. b b0 where loop :: Int -> b -> m b loop Int i b b | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int 0 = b -> m b forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return b b | Bool

otherwise = do a a <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i Int -> b -> m b loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (b -> m b) -> m b -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Int -> a -> b -> m b f Int i a a b b n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

ifoldrM' :: (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b {-# INLINE ifoldrM' #-} ifoldrM' :: forall (m :: * -> *) (v :: * -> * -> *) a b. (PrimMonad m, MVector v a) => (Int -> a -> b -> m b) -> b -> v (PrimState m) a -> m b ifoldrM' Int -> a -> b -> m b f b b0 v (PrimState m) a v = Int -> b -> m b loop (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int

1. b b0 where loop :: Int -> b -> m b loop Int i !b b | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int 0 = b -> m b forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return b b | Bool

otherwise = do a a <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i Int -> b -> m b loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (b -> m b) -> m b -> m b forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Int -> a -> b -> m b f Int i a a b b n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

set :: (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m () {-# INLINE set #-} set :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m () set v (PrimState m) a v = ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) () -> m ()) -> (a -> ST (PrimState m) ()) -> a -> m () forall b c a. (b -> c) -> (a -> b) -> a -> c . v (PrimState m) a -> a -> ST (PrimState m) () forall s. v s a -> a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s () basicSet v (PrimState m) a v

copy :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a
-> v (PrimState m) a
-> m () {-# INLINE copy #-} copy :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () copy v (PrimState m) a dst v (PrimState m) a src = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Bounds String "overlapping vectors" (Bool -> Bool not (v (PrimState m) a dst v (PrimState m) a -> v (PrimState m) a -> Bool forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> Bool overlaps v (PrimState m) a src)) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Bounds String "length mismatch" (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a dst Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a src) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> v (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () unsafeCopy v (PrimState m) a dst v (PrimState m) a src

move :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a
-> v (PrimState m) a
-> m () {-# INLINE move #-} move :: forall (m :: * -> *) (v :: * -> * -> *) a. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () move v (PrimState m) a dst v (PrimState m) a src = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Bounds String "length mismatch" (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a dst Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a src) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> v (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () unsafeMove v (PrimState m) a dst v (PrimState m) a src

unsafeCopy :: (PrimMonad m, MVector v a) => v (PrimState m) a
-> v (PrimState m) a
-> m () {-# INLINE unsafeCopy #-} unsafeCopy :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () unsafeCopy v (PrimState m) a dst v (PrimState m) a src = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Unsafe String "length mismatch" (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a dst Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a src) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Unsafe String "overlapping vectors" (Bool -> Bool not (v (PrimState m) a dst v (PrimState m) a -> v (PrimState m) a -> Bool forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> Bool overlaps v (PrimState m) a src)) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a dst v (PrimState m) a -> m () -> m () forall a b. a -> b -> b seq v (PrimState m) a src v (PrimState m) a -> m () -> m () forall a b. a -> b -> b seq ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (v (PrimState m) a -> v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () basicUnsafeCopy v (PrimState m) a dst v (PrimState m) a src)

unsafeMove :: (PrimMonad m, MVector v a) => v (PrimState m) a
-> v (PrimState m) a
-> m () {-# INLINE unsafeMove #-} unsafeMove :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> v (PrimState m) a -> m () unsafeMove v (PrimState m) a dst v (PrimState m) a src = Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Unsafe String "length mismatch" (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a dst Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a src) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a dst v (PrimState m) a -> m () -> m () forall a b. a -> b -> b seq v (PrimState m) a src v (PrimState m) a -> m () -> m () forall a b. a -> b -> b seq ST (PrimState m) () -> m () forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (v (PrimState m) a -> v (PrimState m) a -> ST (PrimState m) () forall s. v s a -> v s a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a -> ST s () basicUnsafeMove v (PrimState m) a dst v (PrimState m) a src)

accum :: forall m v a b u. (HasCallStack, PrimMonad m, MVector v a) => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () {-# INLINE accum #-} accum :: forall (m :: * -> *) (v :: * -> * -> *) a b (u :: * -> *). (HasCallStack, PrimMonad m, MVector v a) => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () accum a -> b -> a f !v (PrimState m) a v Bundle u (Int, b) s = ((Int, b) -> m ()) -> Bundle u (Int, b) -> m () forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> m b) -> Bundle v a -> m () Bundle.mapM_ HasCallStack => (Int, b) -> m () (Int, b) -> m () upd Bundle u (Int, b) s where {-# INLINE_INNER upd #-} upd :: HasCallStack => (Int, b) -> m () upd :: HasCallStack => (Int, b) -> m () upd (Int i,b b) = do a a <- Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i Int n (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i (a -> b -> a f a a b b) !n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

update :: forall m v a u. (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Bundle u (Int, a) -> m () {-# INLINE update #-} update :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Bundle u (Int, a) -> m () update !v (PrimState m) a v Bundle u (Int, a) s = ((Int, a) -> m ()) -> Bundle u (Int, a) -> m () forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> m b) -> Bundle v a -> m () Bundle.mapM_ HasCallStack => (Int, a) -> m () (Int, a) -> m () upd Bundle u (Int, a) s where {-# INLINE_INNER upd #-} upd :: HasCallStack => (Int, a) -> m () upd :: HasCallStack => (Int, a) -> m () upd (Int i,a b) = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Bounds Int i Int n (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a b

!n :: Int

n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

unsafeAccum :: (PrimMonad m, MVector v a) => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () {-# INLINE unsafeAccum #-} unsafeAccum :: forall (m :: * -> *) (v :: * -> * -> *) a b (u :: * -> *). (PrimMonad m, MVector v a) => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () unsafeAccum a -> b -> a f !v (PrimState m) a v Bundle u (Int, b) s = ((Int, b) -> m ()) -> Bundle u (Int, b) -> m () forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> m b) -> Bundle v a -> m () Bundle.mapM_ (Int, b) -> m () upd Bundle u (Int, b) s where {-# INLINE_INNER upd #-} upd :: (Int, b) -> m () upd (Int i,b b) = do a a <- Checks -> Int -> Int -> m a -> m a forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i Int n (m a -> m a) -> m a -> m a forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i (a -> b -> a f a a b b) !n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

unsafeUpdate :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Bundle u (Int, a) -> m () {-# INLINE unsafeUpdate #-} unsafeUpdate :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => v (PrimState m) a -> Bundle u (Int, a) -> m () unsafeUpdate !v (PrimState m) a v Bundle u (Int, a) s = ((Int, a) -> m ()) -> Bundle u (Int, a) -> m () forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> m b) -> Bundle v a -> m () Bundle.mapM_ (Int, a) -> m () upd Bundle u (Int, a) s where {-# INLINE_INNER upd #-} upd :: (Int, a) -> m () upd (Int i,a b) = Checks -> Int -> Int -> m () -> m () forall a. HasCallStack => Checks -> Int -> Int -> a -> a checkIndex Checks Unsafe Int i Int n (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a b !n :: Int n = v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v

reverse :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m () {-# INLINE reverse #-} reverse :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m () reverse !v (PrimState m) a v = Int -> Int -> m () reverse_loop Int 0 (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. where reverse_loop :: Int -> Int -> m () reverse_loop Int i Int j | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int j = do v (PrimState m) a -> Int -> Int -> m ()

forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m () unsafeSwap v (PrimState m) a v Int i Int j Int -> Int -> m () reverse_loop (Int i Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (Int j Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. reverse_loop Int _ Int _ = () -> m () forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return ()

unstablePartition :: forall m v a. (PrimMonad m, MVector v a) => (a -> Bool) -> v (PrimState m) a -> m Int {-# INLINE unstablePartition #-} unstablePartition :: forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => (a -> Bool) -> v (PrimState m) a -> m Int unstablePartition a -> Bool f !v (PrimState m) a v = Int -> Int -> m Int from_left Int 0 (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v) where

[from_left](#local-6989586621679214181) :: Int -> Int -> [m](#local-6989586621679212542) Int
from_left :: Int -> Int -> m Int

from_left Int i Int j | Int i Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == Int j = Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Int i | Bool otherwise = do a x <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i if a -> Bool f a x then Int -> Int -> m Int from_left (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int

1. Int j else Int -> Int -> m Int

from_right Int i (Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1)

[from_right](#local-6989586621679214185) :: Int -> Int -> [m](#local-6989586621679212542) Int
from_right :: Int -> Int -> m Int

from_right Int i Int j | Int i Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == Int j = Int -> m Int forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Int i | Bool otherwise = do a x <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int j if a -> Bool f a x then do a y <- v (PrimState m) a -> Int -> m a forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) a v Int i v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int j a y Int -> Int -> m Int from_left (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int

1. Int j else Int -> Int -> m Int

from_right Int i (Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1)

unstablePartitionBundle :: (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE unstablePartitionBundle #-} unstablePartitionBundle :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) unstablePartitionBundle a -> Bool f Bundle u a s = case Size -> Maybe Int upperBound (Bundle u a -> Size forall (v :: * -> *) a. Bundle v a -> Size Bundle.size Bundle u a s) of Just Int n -> (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) unstablePartitionMax a -> Bool f Bundle u a s Int n Maybe Int Nothing -> (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) partitionUnknown a -> Bool f Bundle u a s

unstablePartitionMax :: (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE unstablePartitionMax #-} unstablePartitionMax :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) unstablePartitionMax a -> Bool f Bundle u a s Int n = do v (PrimState m) a v <- Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Internal Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n let {-# INLINE_INNER put #-} put :: (Int, Int) -> a -> m (Int, Int) put (Int i, Int j) a x | a -> Bool f a x = do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x (Int, Int) -> m (Int, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1, Int j) | Bool otherwise = do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v (Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int

1. a x (Int, Int) -> m (Int, Int)

forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int i, Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1)

  (Int

i,Int j) <- ((Int, Int) -> a -> m (Int, Int)) -> (Int, Int) -> Bundle u a -> m (Int, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Bundle.foldM' (Int, Int) -> a -> m (Int, Int) put (Int 0, Int n) Bundle u a s (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int i v (PrimState m) a v, Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int j (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int j) v (PrimState m) a v)

partitionBundle :: (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE partitionBundle #-} partitionBundle :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) partitionBundle a -> Bool f Bundle u a s = case Size -> Maybe Int upperBound (Bundle u a -> Size forall (v :: * -> *) a. Bundle v a -> Size Bundle.size Bundle u a s) of Just Int n -> (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) partitionMax a -> Bool f Bundle u a s Int n Maybe Int Nothing -> (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) partitionUnknown a -> Bool f Bundle u a s

partitionMax :: (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE partitionMax #-} partitionMax :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) partitionMax a -> Bool f Bundle u a s Int n = do v (PrimState m) a v <- Checks -> Int -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> a -> a checkLength Checks Internal Int n (m (v (PrimState m) a) -> m (v (PrimState m) a)) -> m (v (PrimState m) a) -> m (v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n

  let {-# INLINE_INNER put #-}
      put :: (Int, Int) -> a -> m (Int, Int)

put (Int i,Int j) a x | a -> Bool f a x = do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int i a x (Int, Int) -> m (Int, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1,Int j)

        | Bool

otherwise = let j' :: Int j' = Int jInt -> Int -> Int forall a. Num a => a -> a -> a -Int 1 in do v (PrimState m) a -> Int -> a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) a v Int j' a x (Int, Int) -> m (Int, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int i,Int j')

  (Int

i,Int j) <- ((Int, Int) -> a -> m (Int, Int)) -> (Int, Int) -> Bundle u a -> m (Int, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Bundle.foldM' (Int, Int) -> a -> m (Int, Int) put (Int 0,Int n) Bundle u a s Checks -> String -> Bool -> m () -> m () forall a. HasCallStack => Checks -> String -> Bool -> a -> a check Checks Internal String "invalid indices" (Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool <= Int j) (m () -> m ()) -> m () -> m () forall a b. (a -> b) -> a -> b $ () -> m () forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return () let l :: v (PrimState m) a l = Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int i v (PrimState m) a v r :: v (PrimState m) a r = Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int j (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -Int j) v (PrimState m) a v v (PrimState m) a -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m () reverse v (PrimState m) a r (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a l,v (PrimState m) a r)

partitionUnknown :: (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE partitionUnknown #-} partitionUnknown :: forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *). (PrimMonad m, MVector v a) => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) partitionUnknown a -> Bool f Bundle u a s = do v (PrimState m) a v1 <- Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 v (PrimState m) a v2 <- Int -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 (v (PrimState m) a v1', Int n1, v (PrimState m) a v2', Int n2) <- ((v (PrimState m) a, Int, v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int, v (PrimState m) a, Int)) -> (v (PrimState m) a, Int, v (PrimState m) a, Int) -> Bundle u a -> m (v (PrimState m) a, Int, v (PrimState m) a, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Bundle.foldM' (v (PrimState m) a, Int, v (PrimState m) a, Int) -> a -> m (v (PrimState m) a, Int, v (PrimState m) a, Int) put (v (PrimState m) a v1, Int 0, v (PrimState m) a v2, Int 0) Bundle u a s Checks -> Int -> Int -> Int -> m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n1 (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v1') (m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a)) -> m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n2 (v (PrimState m) a -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) a v2') (m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a)) -> m (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a b. (a -> b) -> a -> b $ (v (PrimState m) a, v (PrimState m) a) -> m (v (PrimState m) a, v (PrimState m) a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n1 v (PrimState m) a v1', Int -> Int -> v (PrimState m) a -> v (PrimState m) a forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n2 v (PrimState m) a v2') where

{-# INLINE_INNER put #-}
put :: (v (PrimState m) a, Int, v (PrimState m) a, Int)

-> a -> m (v (PrimState m) a, Int, v (PrimState m) a, Int) put (v (PrimState m) a v1, Int i1, v (PrimState m) a v2, Int i2) a x | a -> Bool f a x = do v (PrimState m) a v1' <- v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) a v1 Int i1 a x (v (PrimState m) a, Int, v (PrimState m) a, Int) -> m (v (PrimState m) a, Int, v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v1', Int i1Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1, v (PrimState m) a v2, Int i2) | Bool otherwise = do v (PrimState m) a v2' <- v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) a v2 Int i2 a x (v (PrimState m) a, Int, v (PrimState m) a, Int) -> m (v (PrimState m) a, Int, v (PrimState m) a, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) a v1, Int i1, v (PrimState m) a v2', Int i2Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1)

partitionWithBundle :: (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) {-# INLINE partitionWithBundle #-} partitionWithBundle :: forall (m :: * -> *) (v :: * -> * -> *) a b c (u :: * -> *). (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) partitionWithBundle a -> Either b c f Bundle u a s = case Size -> Maybe Int upperBound (Bundle u a -> Size forall (v :: * -> *) a. Bundle v a -> Size Bundle.size Bundle u a s) of Just Int n -> (a -> Either b c) -> Bundle u a -> Int -> m (v (PrimState m) b, v (PrimState m) c) forall (m :: * -> *) (v :: * -> * -> *) a b c (u :: * -> *). (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> Int -> m (v (PrimState m) b, v (PrimState m) c) partitionWithMax a -> Either b c f Bundle u a s Int n Maybe Int Nothing -> (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) forall (m :: * -> *) (v :: * -> * -> *) (u :: * -> *) a b c. (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) partitionWithUnknown a -> Either b c f Bundle u a s

partitionWithMax :: (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> Int -> m (v (PrimState m) b, v (PrimState m) c) {-# INLINE partitionWithMax #-} partitionWithMax :: forall (m :: * -> *) (v :: * -> * -> *) a b c (u :: * -> *). (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> Int -> m (v (PrimState m) b, v (PrimState m) c) partitionWithMax a -> Either b c f Bundle u a s Int n = do v (PrimState m) b v1 <- Int -> m (v (PrimState m) b) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n v (PrimState m) c v2 <- Int -> m (v (PrimState m) c) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int n let {-# INLINE_INNER put #-} put :: (Int, Int) -> a -> m (Int, Int) put (Int i1, Int i2) a x = case a -> Either b c f a x of Left b b -> do v (PrimState m) b -> Int -> b -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) b v1 Int i1 b b (Int, Int) -> m (Int, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int i1Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1, Int i2) Right c c -> do v (PrimState m) c -> Int -> c -> m () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) c v2 Int i2 c c (Int, Int) -> m (Int, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int i1, Int i2Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1) (Int n1, Int n2) <- ((Int, Int) -> a -> m (Int, Int)) -> (Int, Int) -> Bundle u a -> m (Int, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Bundle.foldM' (Int, Int) -> a -> m (Int, Int) put (Int 0, Int 0) Bundle u a s Checks -> Int -> Int -> Int -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n1 (v (PrimState m) b -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) b v1) (m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c)) -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n2 (v (PrimState m) c -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) c v2) (m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c)) -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a b. (a -> b) -> a -> b $ (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> v (PrimState m) b -> v (PrimState m) b forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n1 v (PrimState m) b v1, Int -> Int -> v (PrimState m) c -> v (PrimState m) c forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n2 v (PrimState m) c v2)

partitionWithUnknown :: forall m v u a b c. (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) {-# INLINE partitionWithUnknown #-} partitionWithUnknown :: forall (m :: * -> *) (v :: * -> * -> *) (u :: * -> *) a b c. (PrimMonad m, MVector v a, MVector v b, MVector v c) => (a -> Either b c) -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c) partitionWithUnknown a -> Either b c f Bundle u a s = do v (PrimState m) b v1 <- Int -> m (v (PrimState m) b) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 v (PrimState m) c v2 <- Int -> m (v (PrimState m) c) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a) unsafeNew Int 0 (v (PrimState m) b v1', Int n1, v (PrimState m) c v2', Int n2) <- ((v (PrimState m) b, Int, v (PrimState m) c, Int) -> a -> m (v (PrimState m) b, Int, v (PrimState m) c, Int)) -> (v (PrimState m) b, Int, v (PrimState m) c, Int) -> Bundle u a -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) forall (m :: * -> *) a b (v :: * -> *). Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a Bundle.foldM' (v (PrimState m) b, Int, v (PrimState m) c, Int) -> a -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) put (v (PrimState m) b v1, Int 0, v (PrimState m) c v2, Int 0) Bundle u a s Checks -> Int -> Int -> Int -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n1 (v (PrimState m) b -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) b v1') (m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c)) -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a b. (a -> b) -> a -> b $ Checks -> Int -> Int -> Int -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a checkSlice Checks Internal Int 0 Int n2 (v (PrimState m) c -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) c v2') (m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c)) -> m (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a b. (a -> b) -> a -> b $ (v (PrimState m) b, v (PrimState m) c) -> m (v (PrimState m) b, v (PrimState m) c) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Int -> Int -> v (PrimState m) b -> v (PrimState m) b forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n1 v (PrimState m) b v1', Int -> Int -> v (PrimState m) c -> v (PrimState m) c forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice Int 0 Int n2 v (PrimState m) c v2') where put :: (v (PrimState m) b, Int, v (PrimState m) c, Int) -> a -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) {-# INLINE_INNER put #-} put :: (v (PrimState m) b, Int, v (PrimState m) c, Int) -> a -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) put (v (PrimState m) b v1, Int i1, v (PrimState m) c v2, Int i2) a x = case a -> Either b c f a x of Left b b -> do v (PrimState m) b v1' <- v (PrimState m) b -> Int -> b -> m (v (PrimState m) b) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) b v1 Int i1 b b (v (PrimState m) b, Int, v (PrimState m) c, Int) -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) b v1', Int i1Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1, v (PrimState m) c v2, Int i2) Right c c -> do v (PrimState m) c v2' <- v (PrimState m) c -> Int -> c -> m (v (PrimState m) c) forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m (v (PrimState m) a) unsafeAppend1 v (PrimState m) c v2 Int i2 c c (v (PrimState m) b, Int, v (PrimState m) c, Int) -> m (v (PrimState m) b, Int, v (PrimState m) c, Int) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (v (PrimState m) b v1, Int i1, v (PrimState m) c v2', Int i2Int -> Int -> Int forall a. Num a => a -> a -> a +Int 1)

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

nextPermutationBy :: (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool {-# INLINE nextPermutationBy #-} nextPermutationBy :: forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool nextPermutationBy e -> e -> Ordering cmp = (e -> e -> Bool) -> v (PrimState m) e -> m Bool forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Bool) -> v (PrimState m) e -> m Bool nextPermutationByLt (\e x e y -> e -> e -> Ordering cmp e x e y Ordering -> Ordering -> Bool forall a. Eq a => a -> a -> Bool == Ordering LT)

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

prevPermutationBy :: (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool {-# INLINE prevPermutationBy #-} prevPermutationBy :: forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Ordering) -> v (PrimState m) e -> m Bool prevPermutationBy e -> e -> Ordering cmp = (e -> e -> Bool) -> v (PrimState m) e -> m Bool forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Bool) -> v (PrimState m) e -> m Bool nextPermutationByLt (\e x e y -> e -> e -> Ordering cmp e x e y Ordering -> Ordering -> Bool forall a. Eq a => a -> a -> Bool == Ordering GT)

nextPermutationByLt :: (PrimMonad m, MVector v e) => (e -> e -> Bool) -> v (PrimState m) e -> m Bool {-# INLINE nextPermutationByLt #-} nextPermutationByLt :: forall (m :: * -> *) (v :: * -> * -> *) e. (PrimMonad m, MVector v e) => (e -> e -> Bool) -> v (PrimState m) e -> m Bool nextPermutationByLt e -> e -> Bool lt v (PrimState m) e v | Int dim Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int 2 = Bool -> m Bool forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Bool False | Bool otherwise = ST (PrimState m) Bool -> m Bool forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a stToPrim (ST (PrimState m) Bool -> m Bool) -> ST (PrimState m) Bool -> m Bool forall a b. (a -> b) -> a -> b $ do !e vlast <- v (PrimState (ST (PrimState m))) e -> Int -> ST (PrimState m) e forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) e v (PrimState (ST (PrimState m))) e v (Int dim Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. Int -> e -> ST (PrimState m) Bool

decrLoop (Int dim Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. e vlast where dim :: Int dim = v (PrimState m) e -> Int forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int length v (PrimState m) e v

   decrLoop :: Int -> e -> ST (PrimState m) Bool

decrLoop !Int i !e vi1 | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool

= Int 0 = do !e vi <- v (PrimState (ST (PrimState m))) e -> Int -> ST (PrimState m) e forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) e v (PrimState (ST (PrimState m))) e v Int i if e vi e -> e -> Bool lt e vi1 then Int -> e -> Int -> e -> Int -> ST (PrimState m) Bool swapLoop Int i e vi (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int

1. e vi1 Int dim else Int -> e -> ST (PrimState m) Bool decrLoop (Int iInt -> Int -> Int forall a. Num a => a -> a -> a -Int

2. e vi decrLoop Int _ !e _ = Bool -> ST (PrimState m) Bool forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return Bool False

   swapLoop :: Int -> e -> Int -> e -> Int -> ST (PrimState m) Bool

swapLoop !Int k !e vk = Int -> e -> Int -> ST (PrimState m) Bool go where

    go :: Int -> e -> Int -> ST (PrimState m) Bool

go !Int l !e vl !Int r | Int r Int -> Int -> Int forall a. Num a => a -> a -> a

• Int l Int -> Int -> Bool forall a. Ord a => a -> a -> Bool <= Int 1 = do

      v (PrimState (ST (PrimState m))) e

-> Int -> e -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) e v (PrimState (ST (PrimState m))) e v Int k e vl v (PrimState (ST (PrimState m))) e -> Int -> e -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () unsafeWrite v (PrimState m) e v (PrimState (ST (PrimState m))) e v Int l e vk v (PrimState (ST (PrimState m))) e -> ST (PrimState m) () forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> m () reverse (v (PrimState (ST (PrimState m))) e -> ST (PrimState m) ()) -> v (PrimState (ST (PrimState m))) e -> ST (PrimState m) () forall a b. (a -> b) -> a -> b $ Int -> Int -> v (PrimState m) e -> v (PrimState m) e forall (v :: * -> * -> *) a s. MVector v a => Int -> Int -> v s a -> v s a unsafeSlice (Int k Int -> Int -> Int forall a. Num a => a -> a -> a

• Int

1. (Int dim Int -> Int -> Int forall a. Num a => a -> a -> a

• Int k Int -> Int -> Int forall a. Num a => a -> a -> a
• Int

1. v (PrimState m) e v Bool -> ST (PrimState m) Bool

forall a. a -> ST (PrimState m) a forall (m :: * -> *) a. Monad m => a -> m a return Bool True go !Int l !e vl !Int r = do !e vmid <- v (PrimState (ST (PrimState m))) e -> Int -> ST (PrimState m) e forall (m :: * -> *) (v :: * -> * -> *) a. (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a unsafeRead v (PrimState m) e v (PrimState (ST (PrimState m))) e v Int mid if e vk e -> e -> Bool lt e vmid then Int -> e -> Int -> ST (PrimState m) Bool go Int mid e vmid Int r else Int -> e -> Int -> ST (PrimState m) Bool go Int l e vl Int mid where !mid :: Int mid = Int l Int -> Int -> Int forall a. Num a => a -> a -> a

• (Int r Int -> Int -> Int forall a. Num a => a -> a -> a

• Int l) Int -> Int -> Int forall a. Bits a => a -> Int -> a shiftR Int 1