BitArray

Documentation

newtype BitArray a

A newtype wrapper which provides an array-like interface to a type, which has instances of Bits, FiniteBits and Num.

You can construct bit arrays by wrapping numeric values:

>>> BitArray (7 :: Int8)
[qq|00000111|]

or directly from numeric literals:

>>> 7 :: BitArray Int8
[qq|00000111|]

or using a binary notation quasi-quoter, assuming you have the QuasiQuotes pragma turned on:

>>> [qq|0111|] :: BitArray Int8
[qq|00000111|]

BitArray derives the Bits and FiniteBits instances from the base type, so it supports all the standard bitwise operations for fixed-size integral types.

Constructors

BitArray a

Instances

Bounded a => Bounded (BitArray a)

Enum a => Enum (BitArray a)

Eq a => Eq (BitArray a)

Integral a => Integral (BitArray a)

Data a => Data (BitArray a)

Num a => Num (BitArray a)

Ord a => Ord (BitArray a)

FiniteBits a => Read (BitArray a)

Parses a literal of zeros and ones.

>>> read "[qq|1110|]" :: BitArray Int8
[qq|00001110|]

>>> unwrap (read "[qq|1110|]") :: Int
14

Real a => Real (BitArray a)

FiniteBits a => Show (BitArray a)

Produces a literal of zeros and ones.

>>> show (BitArray (5 :: Int8))
"[qq|00000101|]"

Ix a => Ix (BitArray a)

FiniteBits a => IsString (BitArray a)

Generic (BitArray a)

Bits a => Bits (BitArray a)

FiniteBits a => FiniteBits (BitArray a)

type Rep (BitArray a)

Constructors and converters

qq :: QuasiQuoter

A binary number quasi-quoter. Produces a numeric literal at compile time. Can be used to construct both bit arrays and integral numbers.

>>> [qq|011|] :: Int
3

>>> [qq|011|] :: BitArray Int8
[qq|00000011|]

unwrap :: BitArray a -> a

Unwrap the underlying value of a bit array.

Strings

toString :: FiniteBits a => BitArray a -> String

Convert into a binary notation string.

>>> toString (BitArray (5 :: Int8))
"00000101"

parseString :: FiniteBits a => String -> Maybe (BitArray a)

Parse a binary notation string.

>>> parseString "123" :: Maybe (BitArray Int8)
Nothing

>>> parseString "101" :: Maybe (BitArray Int8)
Just [qq|00000101|]

Lists

toList :: FiniteBits a => BitArray a -> [a]

Convert into a list of set bits.

The list is ordered from least significant to most significant bit.

fromList :: FiniteBits a => [a] -> BitArray a

Construct from a list of set bits.

toBoolList :: FiniteBits a => BitArray a -> [Bool]

Convert into a list of boolean values, which represent the "set" flags of each bit.

The list is ordered from least significant to most significant bit.

fromBoolList :: FiniteBits a => [Bool] -> BitArray a

Construct from a list of boolean flags for the "set" status of each bit.

The list must be ordered from least significant to most significant bit.

Utils

map :: (FiniteBits a, FiniteBits b) => (a -> b) -> BitArray a -> BitArray b

Map over the set bits.

foldr :: FiniteBits a => (a -> b -> b) -> b -> BitArray a -> b

Perform a right-associative fold over the set bits.

mapM_ :: (FiniteBits a, Monad m) => (a -> m b) -> BitArray a -> m ()

Traverse thru set bits.

traverse_ :: (FiniteBits a, Applicative f) => (a -> f b) -> BitArray a -> f ()

Traverse thru set bits.