foundation-0.0.17: Alternative prelude with batteries and no dependencies

Safe Haskell | None
Language | Haskell2010

Foundation.Bits

Synopsis

- (.<<.) :: Bits a => a -> Int -> a
- (.>>.) :: Bits a => a -> Int -> a
- class Eq a => Bits a where
- alignRoundUp :: Int -> Int -> Int
- alignRoundDown :: Int -> Int -> Int

# Documentation

(.<<.) :: Bits a => a -> Int -> a Source #

Unsafe Shift Left Operator

(.>>.) :: Bits a => a -> Int -> a Source #

Unsafe Shift Right Operator

class Eq a => Bits a where #

The `Bits` class defines bitwise operations over integral types.

- Bits are numbered from 0 with bit 0 being the least significant bit.

Minimal complete definition

(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount

Methods

(.&.) :: a -> a -> a infixl 7 #

Bitwise "and"

(.|.) :: a -> a -> a infixl 5 #

Bitwise "or"

xor :: a -> a -> a infixl 6 #

Bitwise "xor"

complement :: a -> a #

Reverse all the bits in the argument

shift :: a -> Int -> a infixl 8 #

``shift` x i` shifts `x` left by `i` bits if `i` is positive, or right by `-i` bits otherwise. Right shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the `x` is negative and with 0 otherwise.

An instance can define either this unified `shift` or `shiftL` and `shiftR`, depending on which is more convenient for the type in question.

rotate :: a -> Int -> a infixl 8 #

``rotate` x i` rotates `x` left by `i` bits if `i` is positive, or right by `-i` bits otherwise.

For unbounded types like `Integer`, `rotate` is equivalent to `shift`.

An instance can define either this unified `rotate` or `rotateL` and `rotateR`, depending on which is more convenient for the type in question.

zeroBits :: a #

`zeroBits` is the value with all bits unset.

The following laws ought to hold (for all valid bit indices `n`):

-     clearBit zeroBits n == zeroBits

-     setBit   zeroBits n == bit n

-     testBit  zeroBits n == False

-     popCount zeroBits   == 0

This method uses ``clearBit` (`bit` 0) 0` as its default implementation (which ought to be equivalent to `zeroBits` for types which possess a 0th bit).

Since: 4.7.0.0

bit :: Int -> a #

`bit i` is a value with the `i`th bit set and all other bits clear.

Can be implemented using `bitDefault` if `a` is also an instance of `Num`.

See also `zeroBits`.

setBit :: a -> Int -> a #

`x `setBit` i` is the same as `x .|. bit i`

clearBit :: a -> Int -> a #

`x `clearBit` i` is the same as `x .&. complement (bit i)`

complementBit :: a -> Int -> a #

`x `complementBit` i` is the same as `x `xor` bit i`

testBit :: a -> Int -> Bool #

Return `True` if the `n`th bit of the argument is 1

Can be implemented using `testBitDefault` if `a` is also an instance of `Num`.

bitSizeMaybe :: a -> Maybe Int #

Return the number of bits in the type of the argument. The actual value of the argument is ignored. Returns Nothing for types that do not have a fixed bitsize, like `Integer`.

Since: 4.7.0.0

bitSize :: a -> Int #

Return the number of bits in the type of the argument. The actual value of the argument is ignored. The function `bitSize` is undefined for types that do not have a fixed bitsize, like `Integer`.

isSigned :: a -> Bool #

Return `True` if the argument is a signed type. The actual value of the argument is ignored

shiftL :: a -> Int -> a infixl 8 #

Shift the argument left by the specified number of bits (which must be non-negative).

An instance can define either this and `shiftR` or the unified `shift`, depending on which is more convenient for the type in question.

unsafeShiftL :: a -> Int -> a #

Shift the argument left by the specified number of bits. The result is undefined for negative shift amounts and shift amounts greater or equal to the `bitSize`.

Defaults to `shiftL` unless defined explicitly by an instance.

Since: 4.5.0.0

shiftR :: a -> Int -> a infixl 8 #

Shift the first argument right by the specified number of bits. The result is undefined for negative shift amounts and shift amounts greater or equal to the `bitSize`.

Right shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the `x` is negative and with 0 otherwise.

An instance can define either this and `shiftL` or the unified `shift`, depending on which is more convenient for the type in question.

unsafeShiftR :: a -> Int -> a #

Shift the first argument right by the specified number of bits, which must be non-negative an smaller than the number of bits in the type.

Right shifts perform sign extension on signed number types; i.e. they fill the top bits with 1 if the `x` is negative and with 0 otherwise.

Defaults to `shiftR` unless defined explicitly by an instance.

Since: 4.5.0.0

rotateL :: a -> Int -> a infixl 8 #

Rotate the argument left by the specified number of bits (which must be non-negative).

An instance can define either this and `rotateR` or the unified `rotate`, depending on which is more convenient for the type in question.

rotateR :: a -> Int -> a infixl 8 #

Rotate the argument right by the specified number of bits (which must be non-negative).

An instance can define either this and `rotateL` or the unified `rotate`, depending on which is more convenient for the type in question.

popCount :: a -> Int #

Return the number of set bits in the argument. This number is known as the population count or the Hamming weight.

Can be implemented using `popCountDefault` if `a` is also an instance of `Num`.

Since: 4.5.0.0

Instances

Bits Bool |

Methods

(.&.) :: Bool -> Bool -> Bool #

(.|.) :: Bool -> Bool -> Bool #

xor :: Bool -> Bool -> Bool #

complement :: Bool -> Bool #

shift :: Bool -> Int -> Bool #

rotate :: Bool -> Int -> Bool #

zeroBits :: Bool #

bit :: Int -> Bool #

setBit :: Bool -> Int -> Bool #

clearBit :: Bool -> Int -> Bool #

complementBit :: Bool -> Int -> Bool #

testBit :: Bool -> Int -> Bool #

bitSizeMaybe :: Bool -> Maybe Int #

bitSize :: Bool -> Int #

isSigned :: Bool -> Bool #

shiftL :: Bool -> Int -> Bool #

unsafeShiftL :: Bool -> Int -> Bool #

shiftR :: Bool -> Int -> Bool #

unsafeShiftR :: Bool -> Int -> Bool #

rotateL :: Bool -> Int -> Bool #

rotateR :: Bool -> Int -> Bool #

popCount :: Bool -> Int #

Bits Int |

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

Bits Int8 |

Methods

(.&.) :: Int8 -> Int8 -> Int8 #

(.|.) :: Int8 -> Int8 -> Int8 #

xor :: Int8 -> Int8 -> Int8 #

complement :: Int8 -> Int8 #

shift :: Int8 -> Int -> Int8 #

rotate :: Int8 -> Int -> Int8 #

zeroBits :: Int8 #

bit :: Int -> Int8 #

setBit :: Int8 -> Int -> Int8 #

clearBit :: Int8 -> Int -> Int8 #

complementBit :: Int8 -> Int -> Int8 #

testBit :: Int8 -> Int -> Bool #

bitSizeMaybe :: Int8 -> Maybe Int #

bitSize :: Int8 -> Int #

isSigned :: Int8 -> Bool #

shiftL :: Int8 -> Int -> Int8 #

unsafeShiftL :: Int8 -> Int -> Int8 #

shiftR :: Int8 -> Int -> Int8 #

unsafeShiftR :: Int8 -> Int -> Int8 #

rotateL :: Int8 -> Int -> Int8 #

rotateR :: Int8 -> Int -> Int8 #

popCount :: Int8 -> Int #

Bits Int16 |

Methods

(.&.) :: Int16 -> Int16 -> Int16 #

(.|.) :: Int16 -> Int16 -> Int16 #

xor :: Int16 -> Int16 -> Int16 #

complement :: Int16 -> Int16 #

shift :: Int16 -> Int -> Int16 #

rotate :: Int16 -> Int -> Int16 #

zeroBits :: Int16 #

bit :: Int -> Int16 #

setBit :: Int16 -> Int -> Int16 #

clearBit :: Int16 -> Int -> Int16 #

complementBit :: Int16 -> Int -> Int16 #

testBit :: Int16 -> Int -> Bool #

bitSizeMaybe :: Int16 -> Maybe Int #

bitSize :: Int16 -> Int #

isSigned :: Int16 -> Bool #

shiftL :: Int16 -> Int -> Int16 #

unsafeShiftL :: Int16 -> Int -> Int16 #

shiftR :: Int16 -> Int -> Int16 #

unsafeShiftR :: Int16 -> Int -> Int16 #

rotateL :: Int16 -> Int -> Int16 #

rotateR :: Int16 -> Int -> Int16 #

popCount :: Int16 -> Int #

Bits Int32 |

Methods

(.&.) :: Int32 -> Int32 -> Int32 #

(.|.) :: Int32 -> Int32 -> Int32 #

xor :: Int32 -> Int32 -> Int32 #

complement :: Int32 -> Int32 #

shift :: Int32 -> Int -> Int32 #

rotate :: Int32 -> Int -> Int32 #

zeroBits :: Int32 #

bit :: Int -> Int32 #

setBit :: Int32 -> Int -> Int32 #

clearBit :: Int32 -> Int -> Int32 #

complementBit :: Int32 -> Int -> Int32 #

testBit :: Int32 -> Int -> Bool #

bitSizeMaybe :: Int32 -> Maybe Int #

bitSize :: Int32 -> Int #

isSigned :: Int32 -> Bool #

shiftL :: Int32 -> Int -> Int32 #

unsafeShiftL :: Int32 -> Int -> Int32 #

shiftR :: Int32 -> Int -> Int32 #

unsafeShiftR :: Int32 -> Int -> Int32 #

rotateL :: Int32 -> Int -> Int32 #

rotateR :: Int32 -> Int -> Int32 #

popCount :: Int32 -> Int #

Bits Int64 |

Methods

(.&.) :: Int64 -> Int64 -> Int64 #

(.|.) :: Int64 -> Int64 -> Int64 #

xor :: Int64 -> Int64 -> Int64 #

complement :: Int64 -> Int64 #

shift :: Int64 -> Int -> Int64 #

rotate :: Int64 -> Int -> Int64 #

zeroBits :: Int64 #

bit :: Int -> Int64 #

setBit :: Int64 -> Int -> Int64 #

clearBit :: Int64 -> Int -> Int64 #

complementBit :: Int64 -> Int -> Int64 #

testBit :: Int64 -> Int -> Bool #

bitSizeMaybe :: Int64 -> Maybe Int #

bitSize :: Int64 -> Int #

isSigned :: Int64 -> Bool #

shiftL :: Int64 -> Int -> Int64 #

unsafeShiftL :: Int64 -> Int -> Int64 #

shiftR :: Int64 -> Int -> Int64 #

unsafeShiftR :: Int64 -> Int -> Int64 #

rotateL :: Int64 -> Int -> Int64 #

rotateR :: Int64 -> Int -> Int64 #

popCount :: Int64 -> Int #

Bits Integer |

Methods

(.&.) :: Integer -> Integer -> Integer #

(.|.) :: Integer -> Integer -> Integer #

xor :: Integer -> Integer -> Integer #

complement :: Integer -> Integer #

shift :: Integer -> Int -> Integer #

rotate :: Integer -> Int -> Integer #

zeroBits :: Integer #

bit :: Int -> Integer #

setBit :: Integer -> Int -> Integer #

clearBit :: Integer -> Int -> Integer #

complementBit :: Integer -> Int -> Integer #

testBit :: Integer -> Int -> Bool #

bitSizeMaybe :: Integer -> Maybe Int #

bitSize :: Integer -> Int #

isSigned :: Integer -> Bool #

shiftL :: Integer -> Int -> Integer #

unsafeShiftL :: Integer -> Int -> Integer #

shiftR :: Integer -> Int -> Integer #

unsafeShiftR :: Integer -> Int -> Integer #

rotateL :: Integer -> Int -> Integer #

rotateR :: Integer -> Int -> Integer #

popCount :: Integer -> Int #

Bits Word |

Methods

(.&.) :: Word -> Word -> Word #

(.|.) :: Word -> Word -> Word #

xor :: Word -> Word -> Word #

complement :: Word -> Word #

shift :: Word -> Int -> Word #

rotate :: Word -> Int -> Word #

zeroBits :: Word #

bit :: Int -> Word #

setBit :: Word -> Int -> Word #

clearBit :: Word -> Int -> Word #

complementBit :: Word -> Int -> Word #

testBit :: Word -> Int -> Bool #

bitSizeMaybe :: Word -> Maybe Int #

bitSize :: Word -> Int #

isSigned :: Word -> Bool #

shiftL :: Word -> Int -> Word #

unsafeShiftL :: Word -> Int -> Word #

shiftR :: Word -> Int -> Word #

unsafeShiftR :: Word -> Int -> Word #

rotateL :: Word -> Int -> Word #

rotateR :: Word -> Int -> Word #

popCount :: Word -> Int #

Bits Word8 |

Methods

(.&.) :: Word8 -> Word8 -> Word8 #

(.|.) :: Word8 -> Word8 -> Word8 #

xor :: Word8 -> Word8 -> Word8 #

complement :: Word8 -> Word8 #

shift :: Word8 -> Int -> Word8 #

rotate :: Word8 -> Int -> Word8 #

zeroBits :: Word8 #

bit :: Int -> Word8 #

setBit :: Word8 -> Int -> Word8 #

clearBit :: Word8 -> Int -> Word8 #

complementBit :: Word8 -> Int -> Word8 #

testBit :: Word8 -> Int -> Bool #

bitSizeMaybe :: Word8 -> Maybe Int #

bitSize :: Word8 -> Int #

isSigned :: Word8 -> Bool #

shiftL :: Word8 -> Int -> Word8 #

unsafeShiftL :: Word8 -> Int -> Word8 #

shiftR :: Word8 -> Int -> Word8 #

unsafeShiftR :: Word8 -> Int -> Word8 #

rotateL :: Word8 -> Int -> Word8 #

rotateR :: Word8 -> Int -> Word8 #

popCount :: Word8 -> Int #

Bits Word16 |

Methods

(.&.) :: Word16 -> Word16 -> Word16 #

(.|.) :: Word16 -> Word16 -> Word16 #

xor :: Word16 -> Word16 -> Word16 #

complement :: Word16 -> Word16 #

shift :: Word16 -> Int -> Word16 #

rotate :: Word16 -> Int -> Word16 #

zeroBits :: Word16 #

bit :: Int -> Word16 #

setBit :: Word16 -> Int -> Word16 #

clearBit :: Word16 -> Int -> Word16 #

complementBit :: Word16 -> Int -> Word16 #

testBit :: Word16 -> Int -> Bool #

bitSizeMaybe :: Word16 -> Maybe Int #

bitSize :: Word16 -> Int #

isSigned :: Word16 -> Bool #

shiftL :: Word16 -> Int -> Word16 #

unsafeShiftL :: Word16 -> Int -> Word16 #

shiftR :: Word16 -> Int -> Word16 #

unsafeShiftR :: Word16 -> Int -> Word16 #

rotateL :: Word16 -> Int -> Word16 #

rotateR :: Word16 -> Int -> Word16 #

popCount :: Word16 -> Int #

Bits Word32 |

Methods

(.&.) :: Word32 -> Word32 -> Word32 #

(.|.) :: Word32 -> Word32 -> Word32 #

xor :: Word32 -> Word32 -> Word32 #

complement :: Word32 -> Word32 #

shift :: Word32 -> Int -> Word32 #

rotate :: Word32 -> Int -> Word32 #

zeroBits :: Word32 #

bit :: Int -> Word32 #

setBit :: Word32 -> Int -> Word32 #

clearBit :: Word32 -> Int -> Word32 #

complementBit :: Word32 -> Int -> Word32 #

testBit :: Word32 -> Int -> Bool #

bitSizeMaybe :: Word32 -> Maybe Int #

bitSize :: Word32 -> Int #

isSigned :: Word32 -> Bool #

shiftL :: Word32 -> Int -> Word32 #

unsafeShiftL :: Word32 -> Int -> Word32 #

shiftR :: Word32 -> Int -> Word32 #

unsafeShiftR :: Word32 -> Int -> Word32 #

rotateL :: Word32 -> Int -> Word32 #

rotateR :: Word32 -> Int -> Word32 #

popCount :: Word32 -> Int #

Bits Word64 |

Methods

(.&.) :: Word64 -> Word64 -> Word64 #

(.|.) :: Word64 -> Word64 -> Word64 #

xor :: Word64 -> Word64 -> Word64 #

complement :: Word64 -> Word64 #

shift :: Word64 -> Int -> Word64 #

rotate :: Word64 -> Int -> Word64 #

zeroBits :: Word64 #

bit :: Int -> Word64 #

setBit :: Word64 -> Int -> Word64 #

clearBit :: Word64 -> Int -> Word64 #

complementBit :: Word64 -> Int -> Word64 #

testBit :: Word64 -> Int -> Bool #

bitSizeMaybe :: Word64 -> Maybe Int #

bitSize :: Word64 -> Int #

isSigned :: Word64 -> Bool #

shiftL :: Word64 -> Int -> Word64 #

unsafeShiftL :: Word64 -> Int -> Word64 #

shiftR :: Word64 -> Int -> Word64 #

unsafeShiftR :: Word64 -> Int -> Word64 #

rotateL :: Word64 -> Int -> Word64 #

rotateR :: Word64 -> Int -> Word64 #

popCount :: Word64 -> Int #

Bits Natural |

Methods

(.&.) :: Natural -> Natural -> Natural #

(.|.) :: Natural -> Natural -> Natural #

xor :: Natural -> Natural -> Natural #

complement :: Natural -> Natural #

shift :: Natural -> Int -> Natural #

rotate :: Natural -> Int -> Natural #

zeroBits :: Natural #

bit :: Int -> Natural #

setBit :: Natural -> Int -> Natural #

clearBit :: Natural -> Int -> Natural #

complementBit :: Natural -> Int -> Natural #

testBit :: Natural -> Int -> Bool #

bitSizeMaybe :: Natural -> Maybe Int #

bitSize :: Natural -> Int #

isSigned :: Natural -> Bool #

shiftL :: Natural -> Int -> Natural #

unsafeShiftL :: Natural -> Int -> Natural #

shiftR :: Natural -> Int -> Natural #

unsafeShiftR :: Natural -> Int -> Natural #

rotateL :: Natural -> Int -> Natural #

rotateR :: Natural -> Int -> Natural #

popCount :: Natural -> Int #

Bits CDev |

Methods

(.&.) :: CDev -> CDev -> CDev #

(.|.) :: CDev -> CDev -> CDev #

xor :: CDev -> CDev -> CDev #

complement :: CDev -> CDev #

shift :: CDev -> Int -> CDev #

rotate :: CDev -> Int -> CDev #

zeroBits :: CDev #

bit :: Int -> CDev #

setBit :: CDev -> Int -> CDev #

clearBit :: CDev -> Int -> CDev #

complementBit :: CDev -> Int -> CDev #

testBit :: CDev -> Int -> Bool #

bitSizeMaybe :: CDev -> Maybe Int #

bitSize :: CDev -> Int #

isSigned :: CDev -> Bool #

shiftL :: CDev -> Int -> CDev #

unsafeShiftL :: CDev -> Int -> CDev #

shiftR :: CDev -> Int -> CDev #

unsafeShiftR :: CDev -> Int -> CDev #

rotateL :: CDev -> Int -> CDev #

rotateR :: CDev -> Int -> CDev #

popCount :: CDev -> Int #

Bits CIno |

Methods

(.&.) :: CIno -> CIno -> CIno #

(.|.) :: CIno -> CIno -> CIno #

xor :: CIno -> CIno -> CIno #

complement :: CIno -> CIno #

shift :: CIno -> Int -> CIno #

rotate :: CIno -> Int -> CIno #

zeroBits :: CIno #

bit :: Int -> CIno #

setBit :: CIno -> Int -> CIno #

clearBit :: CIno -> Int -> CIno #

complementBit :: CIno -> Int -> CIno #

testBit :: CIno -> Int -> Bool #

bitSizeMaybe :: CIno -> Maybe Int #

bitSize :: CIno -> Int #

isSigned :: CIno -> Bool #

shiftL :: CIno -> Int -> CIno #

unsafeShiftL :: CIno -> Int -> CIno #

shiftR :: CIno -> Int -> CIno #

unsafeShiftR :: CIno -> Int -> CIno #

rotateL :: CIno -> Int -> CIno #

rotateR :: CIno -> Int -> CIno #

popCount :: CIno -> Int #

Bits CMode |

Methods

(.&.) :: CMode -> CMode -> CMode #

(.|.) :: CMode -> CMode -> CMode #

xor :: CMode -> CMode -> CMode #

complement :: CMode -> CMode #

shift :: CMode -> Int -> CMode #

rotate :: CMode -> Int -> CMode #

zeroBits :: CMode #

bit :: Int -> CMode #

setBit :: CMode -> Int -> CMode #

clearBit :: CMode -> Int -> CMode #

complementBit :: CMode -> Int -> CMode #

testBit :: CMode -> Int -> Bool #

bitSizeMaybe :: CMode -> Maybe Int #

bitSize :: CMode -> Int #

isSigned :: CMode -> Bool #

shiftL :: CMode -> Int -> CMode #

unsafeShiftL :: CMode -> Int -> CMode #

shiftR :: CMode -> Int -> CMode #

unsafeShiftR :: CMode -> Int -> CMode #

rotateL :: CMode -> Int -> CMode #

rotateR :: CMode -> Int -> CMode #

popCount :: CMode -> Int #

Bits COff |

Methods

(.&.) :: COff -> COff -> COff #

(.|.) :: COff -> COff -> COff #

xor :: COff -> COff -> COff #

complement :: COff -> COff #

shift :: COff -> Int -> COff #

rotate :: COff -> Int -> COff #

zeroBits :: COff #

bit :: Int -> COff #

setBit :: COff -> Int -> COff #

clearBit :: COff -> Int -> COff #

complementBit :: COff -> Int -> COff #

testBit :: COff -> Int -> Bool #

bitSizeMaybe :: COff -> Maybe Int #

bitSize :: COff -> Int #

isSigned :: COff -> Bool #

shiftL :: COff -> Int -> COff #

unsafeShiftL :: COff -> Int -> COff #

shiftR :: COff -> Int -> COff #

unsafeShiftR :: COff -> Int -> COff #

rotateL :: COff -> Int -> COff #

rotateR :: COff -> Int -> COff #

popCount :: COff -> Int #

Bits CPid |

Methods

(.&.) :: CPid -> CPid -> CPid #

(.|.) :: CPid -> CPid -> CPid #

xor :: CPid -> CPid -> CPid #

complement :: CPid -> CPid #

shift :: CPid -> Int -> CPid #

rotate :: CPid -> Int -> CPid #

zeroBits :: CPid #

bit :: Int -> CPid #

setBit :: CPid -> Int -> CPid #

clearBit :: CPid -> Int -> CPid #

complementBit :: CPid -> Int -> CPid #

testBit :: CPid -> Int -> Bool #

bitSizeMaybe :: CPid -> Maybe Int #

bitSize :: CPid -> Int #

isSigned :: CPid -> Bool #

shiftL :: CPid -> Int -> CPid #

unsafeShiftL :: CPid -> Int -> CPid #

shiftR :: CPid -> Int -> CPid #

unsafeShiftR :: CPid -> Int -> CPid #

rotateL :: CPid -> Int -> CPid #

rotateR :: CPid -> Int -> CPid #

popCount :: CPid -> Int #

Bits CSsize |

Methods

(.&.) :: CSsize -> CSsize -> CSsize #

(.|.) :: CSsize -> CSsize -> CSsize #

xor :: CSsize -> CSsize -> CSsize #

complement :: CSsize -> CSsize #

shift :: CSsize -> Int -> CSsize #

rotate :: CSsize -> Int -> CSsize #

zeroBits :: CSsize #

bit :: Int -> CSsize #

setBit :: CSsize -> Int -> CSsize #

clearBit :: CSsize -> Int -> CSsize #

complementBit :: CSsize -> Int -> CSsize #

testBit :: CSsize -> Int -> Bool #

bitSizeMaybe :: CSsize -> Maybe Int #

bitSize :: CSsize -> Int #

isSigned :: CSsize -> Bool #

shiftL :: CSsize -> Int -> CSsize #

unsafeShiftL :: CSsize -> Int -> CSsize #

shiftR :: CSsize -> Int -> CSsize #

unsafeShiftR :: CSsize -> Int -> CSsize #

rotateL :: CSsize -> Int -> CSsize #

rotateR :: CSsize -> Int -> CSsize #

popCount :: CSsize -> Int #

Bits CGid |

Methods

(.&.) :: CGid -> CGid -> CGid #

(.|.) :: CGid -> CGid -> CGid #

xor :: CGid -> CGid -> CGid #

complement :: CGid -> CGid #

shift :: CGid -> Int -> CGid #

rotate :: CGid -> Int -> CGid #

zeroBits :: CGid #

bit :: Int -> CGid #

setBit :: CGid -> Int -> CGid #

clearBit :: CGid -> Int -> CGid #

complementBit :: CGid -> Int -> CGid #

testBit :: CGid -> Int -> Bool #

bitSizeMaybe :: CGid -> Maybe Int #

bitSize :: CGid -> Int #

isSigned :: CGid -> Bool #

shiftL :: CGid -> Int -> CGid #

unsafeShiftL :: CGid -> Int -> CGid #

shiftR :: CGid -> Int -> CGid #

unsafeShiftR :: CGid -> Int -> CGid #

rotateL :: CGid -> Int -> CGid #

rotateR :: CGid -> Int -> CGid #

popCount :: CGid -> Int #

Bits CNlink |

Methods

(.&.) :: CNlink -> CNlink -> CNlink #

(.|.) :: CNlink -> CNlink -> CNlink #

xor :: CNlink -> CNlink -> CNlink #

complement :: CNlink -> CNlink #

shift :: CNlink -> Int -> CNlink #

rotate :: CNlink -> Int -> CNlink #

zeroBits :: CNlink #

bit :: Int -> CNlink #

setBit :: CNlink -> Int -> CNlink #

clearBit :: CNlink -> Int -> CNlink #

complementBit :: CNlink -> Int -> CNlink #

testBit :: CNlink -> Int -> Bool #

bitSizeMaybe :: CNlink -> Maybe Int #

bitSize :: CNlink -> Int #

isSigned :: CNlink -> Bool #

shiftL :: CNlink -> Int -> CNlink #

unsafeShiftL :: CNlink -> Int -> CNlink #

shiftR :: CNlink -> Int -> CNlink #

unsafeShiftR :: CNlink -> Int -> CNlink #

rotateL :: CNlink -> Int -> CNlink #

rotateR :: CNlink -> Int -> CNlink #

popCount :: CNlink -> Int #

Bits CUid |

Methods

(.&.) :: CUid -> CUid -> CUid #

(.|.) :: CUid -> CUid -> CUid #

xor :: CUid -> CUid -> CUid #

complement :: CUid -> CUid #

shift :: CUid -> Int -> CUid #

rotate :: CUid -> Int -> CUid #

zeroBits :: CUid #

bit :: Int -> CUid #

setBit :: CUid -> Int -> CUid #

clearBit :: CUid -> Int -> CUid #

complementBit :: CUid -> Int -> CUid #

testBit :: CUid -> Int -> Bool #

bitSizeMaybe :: CUid -> Maybe Int #

bitSize :: CUid -> Int #

isSigned :: CUid -> Bool #

shiftL :: CUid -> Int -> CUid #

unsafeShiftL :: CUid -> Int -> CUid #

shiftR :: CUid -> Int -> CUid #

unsafeShiftR :: CUid -> Int -> CUid #

rotateL :: CUid -> Int -> CUid #

rotateR :: CUid -> Int -> CUid #

popCount :: CUid -> Int #

Bits CTcflag |

Methods

(.&.) :: CTcflag -> CTcflag -> CTcflag #

(.|.) :: CTcflag -> CTcflag -> CTcflag #

xor :: CTcflag -> CTcflag -> CTcflag #

complement :: CTcflag -> CTcflag #

shift :: CTcflag -> Int -> CTcflag #

rotate :: CTcflag -> Int -> CTcflag #

zeroBits :: CTcflag #

bit :: Int -> CTcflag #

setBit :: CTcflag -> Int -> CTcflag #

clearBit :: CTcflag -> Int -> CTcflag #

complementBit :: CTcflag -> Int -> CTcflag #

testBit :: CTcflag -> Int -> Bool #

bitSizeMaybe :: CTcflag -> Maybe Int #

bitSize :: CTcflag -> Int #

isSigned :: CTcflag -> Bool #

shiftL :: CTcflag -> Int -> CTcflag #

unsafeShiftL :: CTcflag -> Int -> CTcflag #

shiftR :: CTcflag -> Int -> CTcflag #

unsafeShiftR :: CTcflag -> Int -> CTcflag #

rotateL :: CTcflag -> Int -> CTcflag #

rotateR :: CTcflag -> Int -> CTcflag #

popCount :: CTcflag -> Int #

Bits CRLim |

Methods

(.&.) :: CRLim -> CRLim -> CRLim #

(.|.) :: CRLim -> CRLim -> CRLim #

xor :: CRLim -> CRLim -> CRLim #

complement :: CRLim -> CRLim #

shift :: CRLim -> Int -> CRLim #

rotate :: CRLim -> Int -> CRLim #

zeroBits :: CRLim #

bit :: Int -> CRLim #

setBit :: CRLim -> Int -> CRLim #

clearBit :: CRLim -> Int -> CRLim #

complementBit :: CRLim -> Int -> CRLim #

testBit :: CRLim -> Int -> Bool #

bitSizeMaybe :: CRLim -> Maybe Int #

bitSize :: CRLim -> Int #

isSigned :: CRLim -> Bool #

shiftL :: CRLim -> Int -> CRLim #

unsafeShiftL :: CRLim -> Int -> CRLim #

shiftR :: CRLim -> Int -> CRLim #

unsafeShiftR :: CRLim -> Int -> CRLim #

rotateL :: CRLim -> Int -> CRLim #

rotateR :: CRLim -> Int -> CRLim #

popCount :: CRLim -> Int #

Bits Fd |

Methods

(.&.) :: Fd -> Fd -> Fd #

(.|.) :: Fd -> Fd -> Fd #

xor :: Fd -> Fd -> Fd #

complement :: Fd -> Fd #

shift :: Fd -> Int -> Fd #

rotate :: Fd -> Int -> Fd #

zeroBits :: Fd #

bit :: Int -> Fd #

setBit :: Fd -> Int -> Fd #

clearBit :: Fd -> Int -> Fd #

complementBit :: Fd -> Int -> Fd #

testBit :: Fd -> Int -> Bool #

bitSizeMaybe :: Fd -> Maybe Int #

bitSize :: Fd -> Int #

isSigned :: Fd -> Bool #

shiftL :: Fd -> Int -> Fd #

unsafeShiftL :: Fd -> Int -> Fd #

shiftR :: Fd -> Int -> Fd #

unsafeShiftR :: Fd -> Int -> Fd #

rotateL :: Fd -> Int -> Fd #

rotateR :: Fd -> Int -> Fd #

popCount :: Fd -> Int #

Bits WordPtr |

Methods

(.&.) :: WordPtr -> WordPtr -> WordPtr #

(.|.) :: WordPtr -> WordPtr -> WordPtr #

xor :: WordPtr -> WordPtr -> WordPtr #

complement :: WordPtr -> WordPtr #

shift :: WordPtr -> Int -> WordPtr #

rotate :: WordPtr -> Int -> WordPtr #

zeroBits :: WordPtr #

bit :: Int -> WordPtr #

setBit :: WordPtr -> Int -> WordPtr #

clearBit :: WordPtr -> Int -> WordPtr #

complementBit :: WordPtr -> Int -> WordPtr #

testBit :: WordPtr -> Int -> Bool #

bitSizeMaybe :: WordPtr -> Maybe Int #

bitSize :: WordPtr -> Int #

isSigned :: WordPtr -> Bool #

shiftL :: WordPtr -> Int -> WordPtr #

unsafeShiftL :: WordPtr -> Int -> WordPtr #

shiftR :: WordPtr -> Int -> WordPtr #

unsafeShiftR :: WordPtr -> Int -> WordPtr #

rotateL :: WordPtr -> Int -> WordPtr #

rotateR :: WordPtr -> Int -> WordPtr #

popCount :: WordPtr -> Int #

Bits IntPtr |

Methods

(.&.) :: IntPtr -> IntPtr -> IntPtr #

(.|.) :: IntPtr -> IntPtr -> IntPtr #

xor :: IntPtr -> IntPtr -> IntPtr #

complement :: IntPtr -> IntPtr #

shift :: IntPtr -> Int -> IntPtr #

rotate :: IntPtr -> Int -> IntPtr #

zeroBits :: IntPtr #

bit :: Int -> IntPtr #

setBit :: IntPtr -> Int -> IntPtr #

clearBit :: IntPtr -> Int -> IntPtr #

complementBit :: IntPtr -> Int -> IntPtr #

testBit :: IntPtr -> Int -> Bool #

bitSizeMaybe :: IntPtr -> Maybe Int #

bitSize :: IntPtr -> Int #

isSigned :: IntPtr -> Bool #

shiftL :: IntPtr -> Int -> IntPtr #

unsafeShiftL :: IntPtr -> Int -> IntPtr #

shiftR :: IntPtr -> Int -> IntPtr #

unsafeShiftR :: IntPtr -> Int -> IntPtr #

rotateL :: IntPtr -> Int -> IntPtr #

rotateR :: IntPtr -> Int -> IntPtr #

popCount :: IntPtr -> Int #

Bits CChar |

Methods

(.&.) :: CChar -> CChar -> CChar #

(.|.) :: CChar -> CChar -> CChar #

xor :: CChar -> CChar -> CChar #

complement :: CChar -> CChar #

shift :: CChar -> Int -> CChar #

rotate :: CChar -> Int -> CChar #

zeroBits :: CChar #

bit :: Int -> CChar #

setBit :: CChar -> Int -> CChar #

clearBit :: CChar -> Int -> CChar #

complementBit :: CChar -> Int -> CChar #

testBit :: CChar -> Int -> Bool #

bitSizeMaybe :: CChar -> Maybe Int #

bitSize :: CChar -> Int #

isSigned :: CChar -> Bool #

shiftL :: CChar -> Int -> CChar #

unsafeShiftL :: CChar -> Int -> CChar #

shiftR :: CChar -> Int -> CChar #

unsafeShiftR :: CChar -> Int -> CChar #

rotateL :: CChar -> Int -> CChar #

rotateR :: CChar -> Int -> CChar #

popCount :: CChar -> Int #

Bits CSChar |

Methods

(.&.) :: CSChar -> CSChar -> CSChar #

(.|.) :: CSChar -> CSChar -> CSChar #

xor :: CSChar -> CSChar -> CSChar #

complement :: CSChar -> CSChar #

shift :: CSChar -> Int -> CSChar #

rotate :: CSChar -> Int -> CSChar #

zeroBits :: CSChar #

bit :: Int -> CSChar #

setBit :: CSChar -> Int -> CSChar #

clearBit :: CSChar -> Int -> CSChar #

complementBit :: CSChar -> Int -> CSChar #

testBit :: CSChar -> Int -> Bool #

bitSizeMaybe :: CSChar -> Maybe Int #

bitSize :: CSChar -> Int #

isSigned :: CSChar -> Bool #

shiftL :: CSChar -> Int -> CSChar #

unsafeShiftL :: CSChar -> Int -> CSChar #

shiftR :: CSChar -> Int -> CSChar #

unsafeShiftR :: CSChar -> Int -> CSChar #

rotateL :: CSChar -> Int -> CSChar #

rotateR :: CSChar -> Int -> CSChar #

popCount :: CSChar -> Int #

Bits CUChar |

Methods

(.&.) :: CUChar -> CUChar -> CUChar #

(.|.) :: CUChar -> CUChar -> CUChar #

xor :: CUChar -> CUChar -> CUChar #

complement :: CUChar -> CUChar #

shift :: CUChar -> Int -> CUChar #

rotate :: CUChar -> Int -> CUChar #

zeroBits :: CUChar #

bit :: Int -> CUChar #

setBit :: CUChar -> Int -> CUChar #

clearBit :: CUChar -> Int -> CUChar #

complementBit :: CUChar -> Int -> CUChar #

testBit :: CUChar -> Int -> Bool #

bitSizeMaybe :: CUChar -> Maybe Int #

bitSize :: CUChar -> Int #

isSigned :: CUChar -> Bool #

shiftL :: CUChar -> Int -> CUChar #

unsafeShiftL :: CUChar -> Int -> CUChar #

shiftR :: CUChar -> Int -> CUChar #

unsafeShiftR :: CUChar -> Int -> CUChar #

rotateL :: CUChar -> Int -> CUChar #

rotateR :: CUChar -> Int -> CUChar #

popCount :: CUChar -> Int #

Bits CShort |

Methods

(.&.) :: CShort -> CShort -> CShort #

(.|.) :: CShort -> CShort -> CShort #

xor :: CShort -> CShort -> CShort #

complement :: CShort -> CShort #

shift :: CShort -> Int -> CShort #

rotate :: CShort -> Int -> CShort #

zeroBits :: CShort #

bit :: Int -> CShort #

setBit :: CShort -> Int -> CShort #

clearBit :: CShort -> Int -> CShort #

complementBit :: CShort -> Int -> CShort #

testBit :: CShort -> Int -> Bool #

bitSizeMaybe :: CShort -> Maybe Int #

bitSize :: CShort -> Int #

isSigned :: CShort -> Bool #

shiftL :: CShort -> Int -> CShort #

unsafeShiftL :: CShort -> Int -> CShort #

shiftR :: CShort -> Int -> CShort #

unsafeShiftR :: CShort -> Int -> CShort #

rotateL :: CShort -> Int -> CShort #

rotateR :: CShort -> Int -> CShort #

popCount :: CShort -> Int #

Bits CUShort |

Methods

(.&.) :: CUShort -> CUShort -> CUShort #

(.|.) :: CUShort -> CUShort -> CUShort #

xor :: CUShort -> CUShort -> CUShort #

complement :: CUShort -> CUShort #

shift :: CUShort -> Int -> CUShort #

rotate :: CUShort -> Int -> CUShort #

zeroBits :: CUShort #

bit :: Int -> CUShort #

setBit :: CUShort -> Int -> CUShort #

clearBit :: CUShort -> Int -> CUShort #

complementBit :: CUShort -> Int -> CUShort #

testBit :: CUShort -> Int -> Bool #

bitSizeMaybe :: CUShort -> Maybe Int #

bitSize :: CUShort -> Int #

isSigned :: CUShort -> Bool #

shiftL :: CUShort -> Int -> CUShort #

unsafeShiftL :: CUShort -> Int -> CUShort #

shiftR :: CUShort -> Int -> CUShort #

unsafeShiftR :: CUShort -> Int -> CUShort #

rotateL :: CUShort -> Int -> CUShort #

rotateR :: CUShort -> Int -> CUShort #

popCount :: CUShort -> Int #

Bits CInt |

Methods

(.&.) :: CInt -> CInt -> CInt #

(.|.) :: CInt -> CInt -> CInt #

xor :: CInt -> CInt -> CInt #

complement :: CInt -> CInt #

shift :: CInt -> Int -> CInt #

rotate :: CInt -> Int -> CInt #

zeroBits :: CInt #

bit :: Int -> CInt #

setBit :: CInt -> Int -> CInt #

clearBit :: CInt -> Int -> CInt #

complementBit :: CInt -> Int -> CInt #

testBit :: CInt -> Int -> Bool #

bitSizeMaybe :: CInt -> Maybe Int #

bitSize :: CInt -> Int #

isSigned :: CInt -> Bool #

shiftL :: CInt -> Int -> CInt #

unsafeShiftL :: CInt -> Int -> CInt #

shiftR :: CInt -> Int -> CInt #

unsafeShiftR :: CInt -> Int -> CInt #

rotateL :: CInt -> Int -> CInt #

rotateR :: CInt -> Int -> CInt #

popCount :: CInt -> Int #

Bits CUInt |

Methods

(.&.) :: CUInt -> CUInt -> CUInt #

(.|.) :: CUInt -> CUInt -> CUInt #

xor :: CUInt -> CUInt -> CUInt #

complement :: CUInt -> CUInt #

shift :: CUInt -> Int -> CUInt #

rotate :: CUInt -> Int -> CUInt #

zeroBits :: CUInt #

bit :: Int -> CUInt #

setBit :: CUInt -> Int -> CUInt #

clearBit :: CUInt -> Int -> CUInt #

complementBit :: CUInt -> Int -> CUInt #

testBit :: CUInt -> Int -> Bool #

bitSizeMaybe :: CUInt -> Maybe Int #

bitSize :: CUInt -> Int #

isSigned :: CUInt -> Bool #

shiftL :: CUInt -> Int -> CUInt #

unsafeShiftL :: CUInt -> Int -> CUInt #

shiftR :: CUInt -> Int -> CUInt #

unsafeShiftR :: CUInt -> Int -> CUInt #

rotateL :: CUInt -> Int -> CUInt #

rotateR :: CUInt -> Int -> CUInt #

popCount :: CUInt -> Int #

Bits CLong |

Methods

(.&.) :: CLong -> CLong -> CLong #

(.|.) :: CLong -> CLong -> CLong #

xor :: CLong -> CLong -> CLong #

complement :: CLong -> CLong #

shift :: CLong -> Int -> CLong #

rotate :: CLong -> Int -> CLong #

zeroBits :: CLong #

bit :: Int -> CLong #

setBit :: CLong -> Int -> CLong #

clearBit :: CLong -> Int -> CLong #

complementBit :: CLong -> Int -> CLong #

testBit :: CLong -> Int -> Bool #

bitSizeMaybe :: CLong -> Maybe Int #

bitSize :: CLong -> Int #

isSigned :: CLong -> Bool #

shiftL :: CLong -> Int -> CLong #

unsafeShiftL :: CLong -> Int -> CLong #

shiftR :: CLong -> Int -> CLong #

unsafeShiftR :: CLong -> Int -> CLong #

rotateL :: CLong -> Int -> CLong #

rotateR :: CLong -> Int -> CLong #

popCount :: CLong -> Int #

Bits CULong |

Methods

(.&.) :: CULong -> CULong -> CULong #

(.|.) :: CULong -> CULong -> CULong #

xor :: CULong -> CULong -> CULong #

complement :: CULong -> CULong #

shift :: CULong -> Int -> CULong #

rotate :: CULong -> Int -> CULong #

zeroBits :: CULong #

bit :: Int -> CULong #

setBit :: CULong -> Int -> CULong #

clearBit :: CULong -> Int -> CULong #

complementBit :: CULong -> Int -> CULong #

testBit :: CULong -> Int -> Bool #

bitSizeMaybe :: CULong -> Maybe Int #

bitSize :: CULong -> Int #

isSigned :: CULong -> Bool #

shiftL :: CULong -> Int -> CULong #

unsafeShiftL :: CULong -> Int -> CULong #

shiftR :: CULong -> Int -> CULong #

unsafeShiftR :: CULong -> Int -> CULong #

rotateL :: CULong -> Int -> CULong #

rotateR :: CULong -> Int -> CULong #

popCount :: CULong -> Int #

Bits CLLong |

Methods

(.&.) :: CLLong -> CLLong -> CLLong #

(.|.) :: CLLong -> CLLong -> CLLong #

xor :: CLLong -> CLLong -> CLLong #

complement :: CLLong -> CLLong #

shift :: CLLong -> Int -> CLLong #

rotate :: CLLong -> Int -> CLLong #

zeroBits :: CLLong #

bit :: Int -> CLLong #

setBit :: CLLong -> Int -> CLLong #

clearBit :: CLLong -> Int -> CLLong #

complementBit :: CLLong -> Int -> CLLong #

testBit :: CLLong -> Int -> Bool #

bitSizeMaybe :: CLLong -> Maybe Int #

bitSize :: CLLong -> Int #

isSigned :: CLLong -> Bool #

shiftL :: CLLong -> Int -> CLLong #

unsafeShiftL :: CLLong -> Int -> CLLong #

shiftR :: CLLong -> Int -> CLLong #

unsafeShiftR :: CLLong -> Int -> CLLong #

rotateL :: CLLong -> Int -> CLLong #

rotateR :: CLLong -> Int -> CLLong #

popCount :: CLLong -> Int #

Bits CULLong |

Methods

(.&.) :: CULLong -> CULLong -> CULLong #

(.|.) :: CULLong -> CULLong -> CULLong #

xor :: CULLong -> CULLong -> CULLong #

complement :: CULLong -> CULLong #

shift :: CULLong -> Int -> CULLong #

rotate :: CULLong -> Int -> CULLong #

zeroBits :: CULLong #

bit :: Int -> CULLong #

setBit :: CULLong -> Int -> CULLong #

clearBit :: CULLong -> Int -> CULLong #

complementBit :: CULLong -> Int -> CULLong #

testBit :: CULLong -> Int -> Bool #

bitSizeMaybe :: CULLong -> Maybe Int #

bitSize :: CULLong -> Int #

isSigned :: CULLong -> Bool #

shiftL :: CULLong -> Int -> CULLong #

unsafeShiftL :: CULLong -> Int -> CULLong #

shiftR :: CULLong -> Int -> CULLong #

unsafeShiftR :: CULLong -> Int -> CULLong #

rotateL :: CULLong -> Int -> CULLong #

rotateR :: CULLong -> Int -> CULLong #

popCount :: CULLong -> Int #

Bits CPtrdiff |

Methods

(.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

(.|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

xor :: CPtrdiff -> CPtrdiff -> CPtrdiff #

complement :: CPtrdiff -> CPtrdiff #

shift :: CPtrdiff -> Int -> CPtrdiff #

rotate :: CPtrdiff -> Int -> CPtrdiff #

zeroBits :: CPtrdiff #

bit :: Int -> CPtrdiff #

setBit :: CPtrdiff -> Int -> CPtrdiff #

clearBit :: CPtrdiff -> Int -> CPtrdiff #

complementBit :: CPtrdiff -> Int -> CPtrdiff #

testBit :: CPtrdiff -> Int -> Bool #

bitSizeMaybe :: CPtrdiff -> Maybe Int #

bitSize :: CPtrdiff -> Int #

isSigned :: CPtrdiff -> Bool #

shiftL :: CPtrdiff -> Int -> CPtrdiff #

unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff #

shiftR :: CPtrdiff -> Int -> CPtrdiff #

unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff #

rotateL :: CPtrdiff -> Int -> CPtrdiff #

rotateR :: CPtrdiff -> Int -> CPtrdiff #

popCount :: CPtrdiff -> Int #

Bits CSize |

Methods

(.&.) :: CSize -> CSize -> CSize #

(.|.) :: CSize -> CSize -> CSize #

xor :: CSize -> CSize -> CSize #

complement :: CSize -> CSize #

shift :: CSize -> Int -> CSize #

rotate :: CSize -> Int -> CSize #

zeroBits :: CSize #

bit :: Int -> CSize #

setBit :: CSize -> Int -> CSize #

clearBit :: CSize -> Int -> CSize #

complementBit :: CSize -> Int -> CSize #

testBit :: CSize -> Int -> Bool #

bitSizeMaybe :: CSize -> Maybe Int #

bitSize :: CSize -> Int #

isSigned :: CSize -> Bool #

shiftL :: CSize -> Int -> CSize #

unsafeShiftL :: CSize -> Int -> CSize #

shiftR :: CSize -> Int -> CSize #

unsafeShiftR :: CSize -> Int -> CSize #

rotateL :: CSize -> Int -> CSize #

rotateR :: CSize -> Int -> CSize #

popCount :: CSize -> Int #

Bits CWchar |

Methods

(.&.) :: CWchar -> CWchar -> CWchar #

(.|.) :: CWchar -> CWchar -> CWchar #

xor :: CWchar -> CWchar -> CWchar #

complement :: CWchar -> CWchar #

shift :: CWchar -> Int -> CWchar #

rotate :: CWchar -> Int -> CWchar #

zeroBits :: CWchar #

bit :: Int -> CWchar #

setBit :: CWchar -> Int -> CWchar #

clearBit :: CWchar -> Int -> CWchar #

complementBit :: CWchar -> Int -> CWchar #

testBit :: CWchar -> Int -> Bool #

bitSizeMaybe :: CWchar -> Maybe Int #

bitSize :: CWchar -> Int #

isSigned :: CWchar -> Bool #

shiftL :: CWchar -> Int -> CWchar #

unsafeShiftL :: CWchar -> Int -> CWchar #

shiftR :: CWchar -> Int -> CWchar #

unsafeShiftR :: CWchar -> Int -> CWchar #

rotateL :: CWchar -> Int -> CWchar #

rotateR :: CWchar -> Int -> CWchar #

popCount :: CWchar -> Int #

Bits CSigAtomic |

Methods

(.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

(.|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

xor :: CSigAtomic -> CSigAtomic -> CSigAtomic #

complement :: CSigAtomic -> CSigAtomic #

shift :: CSigAtomic -> Int -> CSigAtomic #

rotate :: CSigAtomic -> Int -> CSigAtomic #

zeroBits :: CSigAtomic #

bit :: Int -> CSigAtomic #

setBit :: CSigAtomic -> Int -> CSigAtomic #

clearBit :: CSigAtomic -> Int -> CSigAtomic #

complementBit :: CSigAtomic -> Int -> CSigAtomic #

testBit :: CSigAtomic -> Int -> Bool #

bitSizeMaybe :: CSigAtomic -> Maybe Int #

bitSize :: CSigAtomic -> Int #

isSigned :: CSigAtomic -> Bool #

shiftL :: CSigAtomic -> Int -> CSigAtomic #

unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic #

shiftR :: CSigAtomic -> Int -> CSigAtomic #

unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic #

rotateL :: CSigAtomic -> Int -> CSigAtomic #

rotateR :: CSigAtomic -> Int -> CSigAtomic #

popCount :: CSigAtomic -> Int #

Bits CIntPtr |

Methods

(.&.) :: CIntPtr -> CIntPtr -> CIntPtr #

(.|.) :: CIntPtr -> CIntPtr -> CIntPtr #

xor :: CIntPtr -> CIntPtr -> CIntPtr #

complement :: CIntPtr -> CIntPtr #

shift :: CIntPtr -> Int -> CIntPtr #

rotate :: CIntPtr -> Int -> CIntPtr #

zeroBits :: CIntPtr #

bit :: Int -> CIntPtr #

setBit :: CIntPtr -> Int -> CIntPtr #

clearBit :: CIntPtr -> Int -> CIntPtr #

complementBit :: CIntPtr -> Int -> CIntPtr #

testBit :: CIntPtr -> Int -> Bool #

bitSizeMaybe :: CIntPtr -> Maybe Int #

bitSize :: CIntPtr -> Int #

isSigned :: CIntPtr -> Bool #

shiftL :: CIntPtr -> Int -> CIntPtr #

unsafeShiftL :: CIntPtr -> Int -> CIntPtr #

shiftR :: CIntPtr -> Int -> CIntPtr #

unsafeShiftR :: CIntPtr -> Int -> CIntPtr #

rotateL :: CIntPtr -> Int -> CIntPtr #

rotateR :: CIntPtr -> Int -> CIntPtr #

popCount :: CIntPtr -> Int #

Bits CUIntPtr |

Methods

(.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

(.|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

xor :: CUIntPtr -> CUIntPtr -> CUIntPtr #

complement :: CUIntPtr -> CUIntPtr #

shift :: CUIntPtr -> Int -> CUIntPtr #

rotate :: CUIntPtr -> Int -> CUIntPtr #

zeroBits :: CUIntPtr #

bit :: Int -> CUIntPtr #

setBit :: CUIntPtr -> Int -> CUIntPtr #

clearBit :: CUIntPtr -> Int -> CUIntPtr #

complementBit :: CUIntPtr -> Int -> CUIntPtr #

testBit :: CUIntPtr -> Int -> Bool #

bitSizeMaybe :: CUIntPtr -> Maybe Int #

bitSize :: CUIntPtr -> Int #

isSigned :: CUIntPtr -> Bool #

shiftL :: CUIntPtr -> Int -> CUIntPtr #

unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr #

shiftR :: CUIntPtr -> Int -> CUIntPtr #

unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr #

rotateL :: CUIntPtr -> Int -> CUIntPtr #

rotateR :: CUIntPtr -> Int -> CUIntPtr #

popCount :: CUIntPtr -> Int #

Bits CIntMax |

Methods

(.&.) :: CIntMax -> CIntMax -> CIntMax #

(.|.) :: CIntMax -> CIntMax -> CIntMax #

xor :: CIntMax -> CIntMax -> CIntMax #

complement :: CIntMax -> CIntMax #

shift :: CIntMax -> Int -> CIntMax #

rotate :: CIntMax -> Int -> CIntMax #

zeroBits :: CIntMax #

bit :: Int -> CIntMax #

setBit :: CIntMax -> Int -> CIntMax #

clearBit :: CIntMax -> Int -> CIntMax #

complementBit :: CIntMax -> Int -> CIntMax #

testBit :: CIntMax -> Int -> Bool #

bitSizeMaybe :: CIntMax -> Maybe Int #

bitSize :: CIntMax -> Int #

isSigned :: CIntMax -> Bool #

shiftL :: CIntMax -> Int -> CIntMax #

unsafeShiftL :: CIntMax -> Int -> CIntMax #

shiftR :: CIntMax -> Int -> CIntMax #

unsafeShiftR :: CIntMax -> Int -> CIntMax #

rotateL :: CIntMax -> Int -> CIntMax #

rotateR :: CIntMax -> Int -> CIntMax #

popCount :: CIntMax -> Int #

Bits CUIntMax |

Methods

(.&.) :: CUIntMax -> CUIntMax -> CUIntMax #

(.|.) :: CUIntMax -> CUIntMax -> CUIntMax #

xor :: CUIntMax -> CUIntMax -> CUIntMax #

complement :: CUIntMax -> CUIntMax #

shift :: CUIntMax -> Int -> CUIntMax #

rotate :: CUIntMax -> Int -> CUIntMax #

zeroBits :: CUIntMax #

bit :: Int -> CUIntMax #

setBit :: CUIntMax -> Int -> CUIntMax #

clearBit :: CUIntMax -> Int -> CUIntMax #

complementBit :: CUIntMax -> Int -> CUIntMax #

testBit :: CUIntMax -> Int -> Bool #

bitSizeMaybe :: CUIntMax -> Maybe Int #

bitSize :: CUIntMax -> Int #

isSigned :: CUIntMax -> Bool #

shiftL :: CUIntMax -> Int -> CUIntMax #

unsafeShiftL :: CUIntMax -> Int -> CUIntMax #

shiftR :: CUIntMax -> Int -> CUIntMax #

unsafeShiftR :: CUIntMax -> Int -> CUIntMax #

rotateL :: CUIntMax -> Int -> CUIntMax #

rotateR :: CUIntMax -> Int -> CUIntMax #

popCount :: CUIntMax -> Int #

Bits Word256 |

Methods

(.&.) :: Word256 -> Word256 -> Word256 #

(.|.) :: Word256 -> Word256 -> Word256 #

xor :: Word256 -> Word256 -> Word256 #

complement :: Word256 -> Word256 #

shift :: Word256 -> Int -> Word256 #

rotate :: Word256 -> Int -> Word256 #

zeroBits :: Word256 #

bit :: Int -> Word256 #

setBit :: Word256 -> Int -> Word256 #

clearBit :: Word256 -> Int -> Word256 #

complementBit :: Word256 -> Int -> Word256 #

testBit :: Word256 -> Int -> Bool #

bitSizeMaybe :: Word256 -> Maybe Int #

bitSize :: Word256 -> Int #

isSigned :: Word256 -> Bool #

shiftL :: Word256 -> Int -> Word256 #

unsafeShiftL :: Word256 -> Int -> Word256 #

shiftR :: Word256 -> Int -> Word256 #

unsafeShiftR :: Word256 -> Int -> Word256 #

rotateL :: Word256 -> Int -> Word256 #

rotateR :: Word256 -> Int -> Word256 #

popCount :: Word256 -> Int #

Bits Word128 |

Methods

(.&.) :: Word128 -> Word128 -> Word128 #

(.|.) :: Word128 -> Word128 -> Word128 #

xor :: Word128 -> Word128 -> Word128 #

complement :: Word128 -> Word128 #

shift :: Word128 -> Int -> Word128 #

rotate :: Word128 -> Int -> Word128 #

zeroBits :: Word128 #

bit :: Int -> Word128 #

setBit :: Word128 -> Int -> Word128 #

clearBit :: Word128 -> Int -> Word128 #

complementBit :: Word128 -> Int -> Word128 #

testBit :: Word128 -> Int -> Bool #

bitSizeMaybe :: Word128 -> Maybe Int #

bitSize :: Word128 -> Int #

isSigned :: Word128 -> Bool #

shiftL :: Word128 -> Int -> Word128 #

unsafeShiftL :: Word128 -> Int -> Word128 #

shiftR :: Word128 -> Int -> Word128 #

unsafeShiftR :: Word128 -> Int -> Word128 #

rotateL :: Word128 -> Int -> Word128 #

rotateR :: Word128 -> Int -> Word128 #

popCount :: Word128 -> Int #

Bits a => Bits (Identity a) |

Methods

(.&.) :: Identity a -> Identity a -> Identity a #

(.|.) :: Identity a -> Identity a -> Identity a #

xor :: Identity a -> Identity a -> Identity a #

complement :: Identity a -> Identity a #

shift :: Identity a -> Int -> Identity a #

rotate :: Identity a -> Int -> Identity a #

zeroBits :: Identity a #

bit :: Int -> Identity a #

setBit :: Identity a -> Int -> Identity a #

clearBit :: Identity a -> Int -> Identity a #

complementBit :: Identity a -> Int -> Identity a #

testBit :: Identity a -> Int -> Bool #

bitSizeMaybe :: Identity a -> Maybe Int #

bitSize :: Identity a -> Int #

isSigned :: Identity a -> Bool #

shiftL :: Identity a -> Int -> Identity a #

unsafeShiftL :: Identity a -> Int -> Identity a #

shiftR :: Identity a -> Int -> Identity a #

unsafeShiftR :: Identity a -> Int -> Identity a #

rotateL :: Identity a -> Int -> Identity a #

rotateR :: Identity a -> Int -> Identity a #

popCount :: Identity a -> Int #

Bits a => Bits (LE a) |

Methods

(.&.) :: LE a -> LE a -> LE a #

(.|.) :: LE a -> LE a -> LE a #

xor :: LE a -> LE a -> LE a #

complement :: LE a -> LE a #

shift :: LE a -> Int -> LE a #

rotate :: LE a -> Int -> LE a #

zeroBits :: LE a #

bit :: Int -> LE a #

setBit :: LE a -> Int -> LE a #

clearBit :: LE a -> Int -> LE a #

complementBit :: LE a -> Int -> LE a #

testBit :: LE a -> Int -> Bool #

bitSizeMaybe :: LE a -> Maybe Int #

bitSize :: LE a -> Int #

isSigned :: LE a -> Bool #

shiftL :: LE a -> Int -> LE a #

unsafeShiftL :: LE a -> Int -> LE a #

shiftR :: LE a -> Int -> LE a #

unsafeShiftR :: LE a -> Int -> LE a #

rotateL :: LE a -> Int -> LE a #

rotateR :: LE a -> Int -> LE a #

popCount :: LE a -> Int #

Bits a => Bits (BE a) |

Methods

(.&.) :: BE a -> BE a -> BE a #

(.|.) :: BE a -> BE a -> BE a #

xor :: BE a -> BE a -> BE a #

complement :: BE a -> BE a #

shift :: BE a -> Int -> BE a #

rotate :: BE a -> Int -> BE a #

zeroBits :: BE a #

bit :: Int -> BE a #

setBit :: BE a -> Int -> BE a #

clearBit :: BE a -> Int -> BE a #

complementBit :: BE a -> Int -> BE a #

testBit :: BE a -> Int -> Bool #

bitSizeMaybe :: BE a -> Maybe Int #

bitSize :: BE a -> Int #

isSigned :: BE a -> Bool #

shiftL :: BE a -> Int -> BE a #

unsafeShiftL :: BE a -> Int -> BE a #

shiftR :: BE a -> Int -> BE a #

unsafeShiftR :: BE a -> Int -> BE a #

rotateL :: BE a -> Int -> BE a #

rotateR :: BE a -> Int -> BE a #

popCount :: BE a -> Int #

Bits a => Bits (Const k a b) |

Methods

(.&.) :: Const k a b -> Const k a b -> Const k a b #

(.|.) :: Const k a b -> Const k a b -> Const k a b #

xor :: Const k a b -> Const k a b -> Const k a b #

complement :: Const k a b -> Const k a b #

shift :: Const k a b -> Int -> Const k a b #

rotate :: Const k a b -> Int -> Const k a b #

zeroBits :: Const k a b #

bit :: Int -> Const k a b #

setBit :: Const k a b -> Int -> Const k a b #

clearBit :: Const k a b -> Int -> Const k a b #

complementBit :: Const k a b -> Int -> Const k a b #

testBit :: Const k a b -> Int -> Bool #

bitSizeMaybe :: Const k a b -> Maybe Int #

bitSize :: Const k a b -> Int #

isSigned :: Const k a b -> Bool #

shiftL :: Const k a b -> Int -> Const k a b #

unsafeShiftL :: Const k a b -> Int -> Const k a b #

shiftR :: Const k a b -> Int -> Const k a b #

unsafeShiftR :: Const k a b -> Int -> Const k a b #

rotateL :: Const k a b -> Int -> Const k a b #

rotateR :: Const k a b -> Int -> Const k a b #

popCount :: Const k a b -> Int #

alignRoundUp Source #

Arguments

:: Int | Number to Align
-> Int | Alignment (power of 2)
-> Int |

Round up (if needed) to a multiple of `alignment` closst to `m`

`alignment` needs to be a power of two

alignRoundUp 16 8 = 16 alignRoundUp 15 8 = 16

alignRoundDown Source #

Arguments

:: Int | Number to Align
-> Int | Alignment (power of 2)
-> Int |

Round down (if needed) to a multiple of `alignment` closest to `m`

`alignment` needs to be a power of two

    alignRoundDown 15 8 = 8
    alignRoundDown 8 8  = 8