Data.Bits.Bitwise

Lifting boolean operations on Bool to bitwise operations on Bits.

Packing bits into words, and unpacking words into bits.

Boolean operations lifted to bitwise operations.

repeat :: (Num b, Bits b) => Bool -> b

Lift a boolean constant to a bitwise constant.

map

Arguments

:: (Num b, Bits b)

=> (Bool -> Bool)

operation

-> b

-> b

Lift a unary boolean operation to a bitwise operation.

The implementation is by exhaustive input/output case analysis: thus the operation provided must be total.

zipWith

Arguments

:: (Num b, Bits b)

=> (Bool -> Bool -> Bool)

operation

-> b

-> b

-> b

Lift a binary boolean operation to a bitwise operation.

The implementation is by exhaustive input/output case analysis: thus the operation provided must be total.

or :: (Num b, Bits b) => b -> Bool

True when any bit is set.

and :: (Num b, Bits b) => b -> Bool

True when all bits are set.

any

Arguments

:: (Num b, Bits b)

=> (Bool -> Bool)

predicate

-> b

-> Bool

True when the predicate is true for any bit.

all

Arguments

:: (Num b, Bits b)

=> (Bool -> Bool)

predicate

-> b

-> Bool

True when the predicate is true for all bits.

isUniform :: (Num b, Bits b) => b -> Maybe Bool

Determine if a Bits is all 1s, all 0s, or neither.

Splitting/joining Bits to/from (lsb, msb).

mask

Arguments

:: (Num b, Bits b)

=> Int

count

-> b

A mask with count least significant bits set.

splitAt

Arguments

:: (Num b, Bits b)

=> Int

split point

-> b

word

-> (b, b)

(lsb, msb)

Split a word into (lsb, msb). Ensures lsb has no set bits above the split point.

joinAt

Arguments

:: (Num b, Bits b)

=> Int

join point

-> b

least significant bits

-> b

most significant bits

-> b

word

Join lsb with msb to make a word. Assumes lsb has no set bits above the join point.

fromBool :: (Num b, Bits b) => Bool -> b

The least significant bit.

(Un)packing Bits to/from lists of Bool.

fromListLE

Arguments

:: (Num b, Bits b)

=> [Bool]

[least significant bit, ..., most significant bit]

-> b

Convert a little-endian list of bits to Bits.

toListLE

Arguments

:: (Num b, Bits b)

=> b

-> [Bool]

[least significant bit, ..., most significant bit]

Convert a Bits (with a defined bitSize) to a list of bits, in little-endian order.

fromListBE

Arguments

:: (Num b, Bits b)

=> [Bool]

[most significant bit, ..., least significant bit]

-> b

Convert a big-endian list of bits to Bits.

toListBE

Arguments

:: (Num b, Bits b)

=> b

-> [Bool]

[most significant bit, ..., least significant bit]

Convert a Bits (with a defined bitSize) to a list of bits, in big-endian order.

(Un)packing Word8 to/from 8-tuples of Bool.

packWord8LE

Arguments

:: Bool

least significant bit

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

most significant bit

-> Word8

Pack bits into a byte in little-endian order.

unpackWord8LE

Arguments

:: Word8

-> (Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool)

(least significant bit, ..., most significant bit)

Extract the bits from a byte in little-endian order.

packWord8BE

Arguments

:: Bool

most significant bit

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

-> Bool

least significant bit

-> Word8

Pack bits into a byte in big-endian order.

unpackWord8BE

Arguments

:: Word8

-> (Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool)

(most significant bit, ..., least significant bit)

Extract the bits from a byte in big-endian order.