Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype BitArray a = BitArray a
- qq :: QuasiQuoter
- unwrap :: BitArray a -> a
- toString :: FiniteBits a => BitArray a -> String
- parseString :: FiniteBits a => String -> Maybe (BitArray a)
- toList :: FiniteBits a => BitArray a -> [a]
- fromList :: FiniteBits a => [a] -> BitArray a
- toBoolList :: FiniteBits a => BitArray a -> [Bool]
- fromBoolList :: FiniteBits a => [Bool] -> BitArray a
- map :: (FiniteBits a, FiniteBits b) => (a -> b) -> BitArray a -> BitArray b
- foldr :: FiniteBits a => (a -> b -> b) -> b -> BitArray a -> b
- mapM_ :: (FiniteBits a, Monad m) => (a -> m b) -> BitArray a -> m ()
- traverse_ :: (FiniteBits a, Applicative f) => (a -> f b) -> BitArray a -> f ()
Documentation
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.
BitArray a |
Bounded a => Bounded (BitArray a) Source # | |
Enum a => Enum (BitArray a) Source # | |
Eq a => Eq (BitArray a) Source # | |
Integral a => Integral (BitArray a) Source # | |
Data a => Data (BitArray a) Source # | |
Num a => Num (BitArray a) Source # | |
Ord a => Ord (BitArray a) Source # | |
FiniteBits a => Read (BitArray a) Source # | Parses a literal of zeros and ones.
|
Real a => Real (BitArray a) Source # | |
FiniteBits a => Show (BitArray a) Source # | Produces a literal of zeros and ones.
|
Ix a => Ix (BitArray a) Source # | |
FiniteBits a => IsString (BitArray a) Source # | |
Generic (BitArray a) Source # | |
Bits a => Bits (BitArray a) Source # | |
FiniteBits a => FiniteBits (BitArray a) Source # | |
type Rep (BitArray a) Source # | |
Constructors and converters
qq :: QuasiQuoter Source #
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|]
Strings
toString :: FiniteBits a => BitArray a -> String Source #
Convert into a binary notation string.
>>>
toString (BitArray (5 :: Int8))
"00000101"
parseString :: FiniteBits a => String -> Maybe (BitArray a) Source #
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] Source #
Convert into a list of set bits.
The list is ordered from least significant to most significant bit.
fromList :: FiniteBits a => [a] -> BitArray a Source #
Construct from a list of set bits.
toBoolList :: FiniteBits a => BitArray a -> [Bool] Source #
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 Source #
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 Source #
Map over the set bits.
foldr :: FiniteBits a => (a -> b -> b) -> b -> BitArray a -> b Source #
Perform a right-associative fold over the set bits.
mapM_ :: (FiniteBits a, Monad m) => (a -> m b) -> BitArray a -> m () Source #
Traverse thru set bits.
traverse_ :: (FiniteBits a, Applicative f) => (a -> f b) -> BitArray a -> f () Source #
Traverse thru set bits.