module Data.Array.Vector.STFreeze (
UA,
UArr, MUArr,
V.streamU, V.unstreamU,
V.toU, V.fromU,
V.emptyU,
V.singletonU,
V.consU,
V.snocU,
V.appendU,
V.headU,
V.lastU,
V.tailU,
V.initU,
V.nullU,
V.unitsU,
V.lengthU,
V.mapU,
V.foldU,
V.fold1U,
V.fold1MaybeU,
V.foldlU,
V.foldl1U,
V.foldl1MaybeU,
V.andU,
V.orU,
V.anyU,
V.allU,
V.sumU, V.productU,
V.maximumU, V.minimumU,
V.maximumByU, V.minimumByU,
V.scanlU,
V.scanl1U,
V.scanU,
V.scan1U,
V.scanResU,
V.mapAccumLU,
V.iterateU,
V.replicateU,
V.replicateEachU,
V.unfoldU,
V.sliceU,
V.takeU,
V.dropU,
V.splitAtU,
V.takeWhileU,
V.dropWhileU,
V.elemU,
V.notElemU,
V.filterU,
V.findU,
V.findIndexU,
V.indexU,
V.lookupU,
V.zipU, V.zip3U,
V.unzipU, V.unzip3U,
V.zipWithU,
V.zipWith3U,
V.fstU,
V.sndU,
V.enumFromToU,
V.enumFromToFracU,
V.enumFromThenToU,
V.enumFromStepLenU,
V.enumFromToEachU,
V.combineU,
V.packU,
V.indexedU,
V.repeatU,
V.UIO(..),
V.lengthMU, newMU, readMU, writeMU, freezeMU, freezeAllMU,
copyMU, permuteMU, atomicUpdateMU, unstreamMU,
memcpyMU, memcpyOffMU, memmoveOffMU,
V.unsafeZipMU, V.unsafeUnzipMU,
) where
import Control.Monad.ST.Freeze
import qualified Data.Array.Vector as V
import Data.Array.Vector(MUArr, UArr, UA, (:*:))
newMU :: (UA e, MonadST st) => Int -> STNormal st s (MUArr e s)
newMU i = liftST (V.newMU i)
readMU :: (UA e, MonadST st) => MUArr e s -> Int -> STRead st s e
readMU a i = liftRead (V.readMU a i)
writeMU :: (UA e, MonadST st) => MUArr e s -> Int -> e -> STNormal st s ()
writeMU a i e = liftST (V.writeMU a i e)
copyMU :: (UA e, MonadST st) => MUArr e s -> Int -> UArr e -> STNormal st s ()
copyMU m i a = liftST (V.copyMU m i a)
freezeMU :: (UA e, MonadST st) => MUArr e s -> Int -> STFreeze st s (UArr e)
freezeMU m i = liftUnsafeFreeze (V.unsafeFreezeMU m i)
memcpyMU :: (UA e, MonadST st) => MUArr e s -> MUArr e s -> Int -> STNormal st s ()
memcpyMU m1 m2 i = liftST (V.memcpyMU m1 m2 i)
memcpyOffMU :: (UA e, MonadST st) => MUArr e s -> MUArr e s -> Int -> Int -> Int -> STNormal st s ()
memcpyOffMU m1 m2 i j k = liftST (V.memcpyOffMU m1 m2 i j k)
memmoveOffMU :: (UA e, MonadST st) => MUArr e s -> MUArr e s -> Int -> Int -> Int -> STNormal st s ()
memmoveOffMU m1 m2 i j k = liftST (V.memmoveOffMU m1 m2 i j k)
freezeAllMU :: (UA e, MonadST st) => MUArr e s -> STFreeze st s (UArr e)
freezeAllMU m = liftUnsafeFreeze (V.unsafeFreezeAllMU m)
permuteMU :: (UA e, MonadST st) => MUArr e s -> UArr e -> UArr Int -> STNormal st s ()
permuteMU m a b = liftST (V.permuteMU m a b)
atomicUpdateMU :: (UA e, MonadST st) => MUArr e s -> UArr (Int :*: e) -> STNormal st s ()
atomicUpdateMU m a = liftST (V.atomicUpdateMU m a)
unstreamMU m s = liftST (V.unstreamMU m s)