module Data.Array.BitArray.ST
( STBitArray()
, getBounds
, newArray
, newArray_
, newListArray
, readArray
, writeArray
, mapArray
, mapIndices
, getElems
, getAssocs
, freeze
, thaw
, copy
, fill
, or
, and
, isUniform
, fold
, map
, zipWith
, unsafeReadArray
, unsafeGetElems
, unsafeFreeze
, unsafeThaw
) where
import Prelude hiding (and, or, map, zipWith)
import Control.Monad.ST (ST)
import Data.Ix (Ix)
import Compat (unsafeIOToST)
import Data.Array.BitArray.Internal (BitArray)
import Data.Array.BitArray.IO (IOBitArray)
import qualified Data.Array.BitArray.IO as IO
newtype STBitArray s i = STB (IOBitArray i)
getBounds :: Ix i => STBitArray s i -> ST s (i, i)
getBounds (STB a) = unsafeIOToST (IO.getBounds a)
newArray :: Ix i => (i, i) -> Bool -> ST s (STBitArray s i)
newArray bs b = STB `fmap` unsafeIOToST (IO.newArray bs b)
newArray_ :: Ix i => (i, i) -> ST s (STBitArray s i)
newArray_ bs = STB `fmap` unsafeIOToST (IO.newArray bs False)
newListArray :: Ix i => (i, i) -> [Bool] -> ST s (STBitArray s i)
newListArray bs es = STB `fmap` unsafeIOToST (IO.newListArray bs es)
readArray :: Ix i => STBitArray s i -> i -> ST s Bool
readArray (STB a) i = unsafeIOToST (IO.readArray a i)
unsafeReadArray :: Ix i => STBitArray s i -> i -> ST s Bool
unsafeReadArray (STB a) i = unsafeIOToST (IO.unsafeReadArray a i)
writeArray :: Ix i => STBitArray s i -> i -> Bool -> ST s ()
writeArray (STB a) i b = unsafeIOToST (IO.writeArray a i b)
mapArray :: Ix i => (Bool -> Bool) -> STBitArray s i -> ST s (STBitArray s i)
mapArray = map
mapIndices :: (Ix i, Ix j) => (i, i) -> (i -> j) -> STBitArray s j -> ST s (STBitArray s i)
mapIndices bs h (STB a) = STB `fmap` unsafeIOToST (IO.mapIndices bs h a)
getElems :: Ix i => STBitArray s i -> ST s [Bool]
getElems (STB a) = unsafeIOToST (IO.getElems a)
unsafeGetElems :: Ix i => STBitArray s i -> ST s [Bool]
unsafeGetElems (STB a) = unsafeIOToST (IO.unsafeGetElems a)
getAssocs :: Ix i => STBitArray s i -> ST s [(i, Bool)]
getAssocs (STB a) = unsafeIOToST (IO.getAssocs a)
freeze :: Ix i => STBitArray s i -> ST s (BitArray i)
freeze (STB a) = unsafeIOToST (IO.freeze a)
unsafeFreeze :: Ix i => STBitArray s i -> ST s (BitArray i)
unsafeFreeze (STB a) = unsafeIOToST (IO.unsafeFreeze a)
thaw :: Ix i => BitArray i -> ST s (STBitArray s i)
thaw a = STB `fmap` unsafeIOToST (IO.thaw a)
unsafeThaw :: Ix i => BitArray i -> ST s (STBitArray s i)
unsafeThaw a = STB `fmap` unsafeIOToST (IO.unsafeThaw a)
copy :: Ix i => STBitArray s i -> ST s (STBitArray s i)
copy (STB a) = STB `fmap` unsafeIOToST (IO.copy a)
fill :: Ix i => STBitArray s i -> Bool -> ST s ()
fill (STB a) b = unsafeIOToST (IO.fill a b)
or :: Ix i => STBitArray s i -> ST s Bool
or (STB a) = unsafeIOToST (IO.or a)
and :: Ix i => STBitArray s i -> ST s Bool
and (STB a) = unsafeIOToST (IO.and a)
isUniform :: Ix i => STBitArray s i -> ST s (Maybe Bool)
isUniform (STB a) = unsafeIOToST (IO.isUniform a)
fold :: Ix i => (Bool -> Bool -> Bool) -> STBitArray s i -> ST s (Maybe Bool)
fold f (STB a) = unsafeIOToST (IO.fold f a)
map :: Ix i => (Bool -> Bool) -> STBitArray s i -> ST s (STBitArray s i)
map f (STB a) = STB `fmap` unsafeIOToST (IO.map f a)
zipWith :: Ix i => (Bool -> Bool -> Bool) -> STBitArray s i -> STBitArray s i -> ST s (STBitArray s i)
zipWith f (STB a) (STB b) = STB `fmap` unsafeIOToST (IO.zipWith f a b)