Data.Array.BitArray.IO

Unboxed mutable bit arrays in the IO monad.

Documentation

data IOBitArray i

The type of mutable bit arrays in the IO monad.

MArray-like interface.

getBounds :: Ix i => IOBitArray i -> IO (i, i)

Get the bounds of a bit array.

newArray

Arguments

:: Ix i

=> (i, i)

bounds

-> Bool

initial value

-> IO (IOBitArray i)

Create a new array filled with an initial value.

newArray_

Arguments

:: Ix i

=> (i, i)

bounds

-> IO (IOBitArray i)

Create a new array filled with unspecified initial values.

newListArray

Arguments

:: Ix i

=> (i, i)

bounds

-> [Bool]

elems

-> IO (IOBitArray i)

Create a new array filled with values from a list.

readArray :: Ix i => IOBitArray i -> i -> IO Bool

Read from an array at an index.

writeArray :: Ix i => IOBitArray i -> i -> Bool -> IO ()

Write to an array at an index.

mapArray :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i)

Alias for map.

mapIndices

Arguments

:: (Ix i, Ix j)

=> (i, i)

new bounds

-> (i -> j)

index transformation

-> IOBitArray j

source array

-> IO (IOBitArray i)

Create a new array by reading from another.

getElems :: Ix i => IOBitArray i -> IO [Bool]

Get a list of all elements of an array.

getAssocs :: Ix i => IOBitArray i -> IO [(i, Bool)]

Get a list of all (index, element) pairs.

Conversion to/from immutable bit arrays.

freeze :: Ix i => IOBitArray i -> IO (BitArray i)

Snapshot the array into an immutable form.

thaw :: Ix i => BitArray i -> IO (IOBitArray i)

Convert an array from immutable form.

Construction

copy :: Ix i => IOBitArray i -> IO (IOBitArray i)

Copy an array.

fill :: Ix i => IOBitArray i -> Bool -> IO ()

Fill an array with a uniform value.

Short-circuiting reductions.

or :: Ix i => IOBitArray i -> IO Bool

Short-circuit bitwise reduction: True when any bit is True.

and :: Ix i => IOBitArray i -> IO Bool

Short-circuit bitwise reduction: False when any bit is False.

isUniform :: Ix i => IOBitArray i -> IO (Maybe Bool)

Short-circuit bitwise reduction: Nothing when any bits differ, Just when all bits are the same.

Aggregate operations.

fold

Arguments

:: Ix i

=> (Bool -> Bool -> Bool)

operator

-> IOBitArray i

-> IO (Maybe Bool)

Bitwise reduction with an associative commutative boolean operator. Implementation lifts from Bool to Bits and folds large chunks at a time. Each bit is used as a source exactly once.

map :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i)

Bitwise map. Implementation lifts from Bool to Bits and maps large chunks at a time.

zipWith :: Ix i => (Bool -> Bool -> Bool) -> IOBitArray i -> IOBitArray i -> IO (IOBitArray i)

Bitwise zipWith. Implementation lifts from Bool to Bits and combines large chunks at a time.

The bounds of the source arrays must be identical.

Unsafe.

unsafeReadArray :: Ix i => IOBitArray i -> i -> IO Bool

Read from an array at an index without bounds checking. Unsafe.

unsafeGetElems :: Ix i => IOBitArray i -> IO [Bool]

Get a list of all elements of an array. Unsafe when the source array can be modified later.

unsafeFreeze :: Ix i => IOBitArray i -> IO (BitArray i)

Snapshot the array into an immutable form. Unsafe when the source array can be modified later.

unsafeThaw :: Ix i => BitArray i -> IO (IOBitArray i)

Convert an array from immutable form. Unsafe to modify the result unless the source array is never used later.