Data.Bits (original) (raw)

Bits CBool Source #

Instance details

Defined in Foreign.C.Types

Methods

(.&.) :: CBool -> CBool -> CBool Source #

(.|.) :: CBool -> CBool -> CBool Source #

xor :: CBool -> CBool -> CBool Source #

complement :: CBool -> CBool Source #

shift :: CBool -> Int -> CBool Source #

rotate :: CBool -> Int -> CBool Source #

zeroBits :: CBool Source #

bit :: Int -> CBool Source #

setBit :: CBool -> Int -> CBool Source #

clearBit :: CBool -> Int -> CBool Source #

complementBit :: CBool -> Int -> CBool Source #

testBit :: CBool -> Int -> Bool Source #

bitSizeMaybe :: CBool -> Maybe Int Source #

bitSize :: CBool -> Int Source #

isSigned :: CBool -> Bool Source #

shiftL :: CBool -> Int -> CBool Source #

unsafeShiftL :: CBool -> Int -> CBool Source #

shiftR :: CBool -> Int -> CBool Source #

unsafeShiftR :: CBool -> Int -> CBool Source #

rotateL :: CBool -> Int -> CBool Source #

rotateR :: CBool -> Int -> CBool Source #

popCount :: CBool -> Int Source #

Bits CChar Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CChar -> CChar -> CChar Source #

complement :: CChar -> CChar Source #

shift :: CChar -> Int -> CChar Source #

rotate :: CChar -> Int -> CChar Source #

zeroBits :: CChar Source #

bit :: Int -> CChar Source #

setBit :: CChar -> Int -> CChar Source #

clearBit :: CChar -> Int -> CChar Source #

complementBit :: CChar -> Int -> CChar Source #

testBit :: CChar -> Int -> Bool Source #

bitSizeMaybe :: CChar -> Maybe Int Source #

bitSize :: CChar -> Int Source #

isSigned :: CChar -> Bool Source #

shiftL :: CChar -> Int -> CChar Source #

unsafeShiftL :: CChar -> Int -> CChar Source #

shiftR :: CChar -> Int -> CChar Source #

unsafeShiftR :: CChar -> Int -> CChar Source #

rotateL :: CChar -> Int -> CChar Source #

rotateR :: CChar -> Int -> CChar Source #

popCount :: CChar -> Int Source #

Bits CInt Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CInt -> CInt -> CInt Source #

complement :: CInt -> CInt Source #

shift :: CInt -> Int -> CInt Source #

rotate :: CInt -> Int -> CInt Source #

zeroBits :: CInt Source #

bit :: Int -> CInt Source #

setBit :: CInt -> Int -> CInt Source #

clearBit :: CInt -> Int -> CInt Source #

complementBit :: CInt -> Int -> CInt Source #

testBit :: CInt -> Int -> Bool Source #

bitSizeMaybe :: CInt -> Maybe Int Source #

bitSize :: CInt -> Int Source #

isSigned :: CInt -> Bool Source #

shiftL :: CInt -> Int -> CInt Source #

unsafeShiftL :: CInt -> Int -> CInt Source #

shiftR :: CInt -> Int -> CInt Source #

unsafeShiftR :: CInt -> Int -> CInt Source #

rotateL :: CInt -> Int -> CInt Source #

rotateR :: CInt -> Int -> CInt Source #

popCount :: CInt -> Int Source #

Bits CIntMax Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CIntMax -> CIntMax -> CIntMax Source #

complement :: CIntMax -> CIntMax Source #

shift :: CIntMax -> Int -> CIntMax Source #

rotate :: CIntMax -> Int -> CIntMax Source #

zeroBits :: CIntMax Source #

bit :: Int -> CIntMax Source #

setBit :: CIntMax -> Int -> CIntMax Source #

clearBit :: CIntMax -> Int -> CIntMax Source #

complementBit :: CIntMax -> Int -> CIntMax Source #

testBit :: CIntMax -> Int -> Bool Source #

bitSizeMaybe :: CIntMax -> Maybe Int Source #

bitSize :: CIntMax -> Int Source #

isSigned :: CIntMax -> Bool Source #

shiftL :: CIntMax -> Int -> CIntMax Source #

unsafeShiftL :: CIntMax -> Int -> CIntMax Source #

shiftR :: CIntMax -> Int -> CIntMax Source #

unsafeShiftR :: CIntMax -> Int -> CIntMax Source #

rotateL :: CIntMax -> Int -> CIntMax Source #

rotateR :: CIntMax -> Int -> CIntMax Source #

popCount :: CIntMax -> Int Source #

Bits CIntPtr Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CIntPtr -> CIntPtr -> CIntPtr Source #

complement :: CIntPtr -> CIntPtr Source #

shift :: CIntPtr -> Int -> CIntPtr Source #

rotate :: CIntPtr -> Int -> CIntPtr Source #

zeroBits :: CIntPtr Source #

bit :: Int -> CIntPtr Source #

setBit :: CIntPtr -> Int -> CIntPtr Source #

clearBit :: CIntPtr -> Int -> CIntPtr Source #

complementBit :: CIntPtr -> Int -> CIntPtr Source #

testBit :: CIntPtr -> Int -> Bool Source #

bitSizeMaybe :: CIntPtr -> Maybe Int Source #

bitSize :: CIntPtr -> Int Source #

isSigned :: CIntPtr -> Bool Source #

shiftL :: CIntPtr -> Int -> CIntPtr Source #

unsafeShiftL :: CIntPtr -> Int -> CIntPtr Source #

shiftR :: CIntPtr -> Int -> CIntPtr Source #

unsafeShiftR :: CIntPtr -> Int -> CIntPtr Source #

rotateL :: CIntPtr -> Int -> CIntPtr Source #

rotateR :: CIntPtr -> Int -> CIntPtr Source #

popCount :: CIntPtr -> Int Source #

Bits CLLong Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CLLong -> CLLong -> CLLong Source #

complement :: CLLong -> CLLong Source #

shift :: CLLong -> Int -> CLLong Source #

rotate :: CLLong -> Int -> CLLong Source #

zeroBits :: CLLong Source #

bit :: Int -> CLLong Source #

setBit :: CLLong -> Int -> CLLong Source #

clearBit :: CLLong -> Int -> CLLong Source #

complementBit :: CLLong -> Int -> CLLong Source #

testBit :: CLLong -> Int -> Bool Source #

bitSizeMaybe :: CLLong -> Maybe Int Source #

bitSize :: CLLong -> Int Source #

isSigned :: CLLong -> Bool Source #

shiftL :: CLLong -> Int -> CLLong Source #

unsafeShiftL :: CLLong -> Int -> CLLong Source #

shiftR :: CLLong -> Int -> CLLong Source #

unsafeShiftR :: CLLong -> Int -> CLLong Source #

rotateL :: CLLong -> Int -> CLLong Source #

rotateR :: CLLong -> Int -> CLLong Source #

popCount :: CLLong -> Int Source #

Bits CLong Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CLong -> CLong -> CLong Source #

complement :: CLong -> CLong Source #

shift :: CLong -> Int -> CLong Source #

rotate :: CLong -> Int -> CLong Source #

zeroBits :: CLong Source #

bit :: Int -> CLong Source #

setBit :: CLong -> Int -> CLong Source #

clearBit :: CLong -> Int -> CLong Source #

complementBit :: CLong -> Int -> CLong Source #

testBit :: CLong -> Int -> Bool Source #

bitSizeMaybe :: CLong -> Maybe Int Source #

bitSize :: CLong -> Int Source #

isSigned :: CLong -> Bool Source #

shiftL :: CLong -> Int -> CLong Source #

unsafeShiftL :: CLong -> Int -> CLong Source #

shiftR :: CLong -> Int -> CLong Source #

unsafeShiftR :: CLong -> Int -> CLong Source #

rotateL :: CLong -> Int -> CLong Source #

rotateR :: CLong -> Int -> CLong Source #

popCount :: CLong -> Int Source #

Bits CPtrdiff Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CPtrdiff -> CPtrdiff -> CPtrdiff Source #

complement :: CPtrdiff -> CPtrdiff Source #

shift :: CPtrdiff -> Int -> CPtrdiff Source #

rotate :: CPtrdiff -> Int -> CPtrdiff Source #

zeroBits :: CPtrdiff Source #

bit :: Int -> CPtrdiff Source #

setBit :: CPtrdiff -> Int -> CPtrdiff Source #

clearBit :: CPtrdiff -> Int -> CPtrdiff Source #

complementBit :: CPtrdiff -> Int -> CPtrdiff Source #

testBit :: CPtrdiff -> Int -> Bool Source #

bitSizeMaybe :: CPtrdiff -> Maybe Int Source #

bitSize :: CPtrdiff -> Int Source #

isSigned :: CPtrdiff -> Bool Source #

shiftL :: CPtrdiff -> Int -> CPtrdiff Source #

unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff Source #

shiftR :: CPtrdiff -> Int -> CPtrdiff Source #

unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff Source #

rotateL :: CPtrdiff -> Int -> CPtrdiff Source #

rotateR :: CPtrdiff -> Int -> CPtrdiff Source #

popCount :: CPtrdiff -> Int Source #

Bits CSChar Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CSChar -> CSChar -> CSChar Source #

complement :: CSChar -> CSChar Source #

shift :: CSChar -> Int -> CSChar Source #

rotate :: CSChar -> Int -> CSChar Source #

zeroBits :: CSChar Source #

bit :: Int -> CSChar Source #

setBit :: CSChar -> Int -> CSChar Source #

clearBit :: CSChar -> Int -> CSChar Source #

complementBit :: CSChar -> Int -> CSChar Source #

testBit :: CSChar -> Int -> Bool Source #

bitSizeMaybe :: CSChar -> Maybe Int Source #

bitSize :: CSChar -> Int Source #

isSigned :: CSChar -> Bool Source #

shiftL :: CSChar -> Int -> CSChar Source #

unsafeShiftL :: CSChar -> Int -> CSChar Source #

shiftR :: CSChar -> Int -> CSChar Source #

unsafeShiftR :: CSChar -> Int -> CSChar Source #

rotateL :: CSChar -> Int -> CSChar Source #

rotateR :: CSChar -> Int -> CSChar Source #

popCount :: CSChar -> Int Source #

Bits CShort Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CShort -> CShort -> CShort Source #

complement :: CShort -> CShort Source #

shift :: CShort -> Int -> CShort Source #

rotate :: CShort -> Int -> CShort Source #

zeroBits :: CShort Source #

bit :: Int -> CShort Source #

setBit :: CShort -> Int -> CShort Source #

clearBit :: CShort -> Int -> CShort Source #

complementBit :: CShort -> Int -> CShort Source #

testBit :: CShort -> Int -> Bool Source #

bitSizeMaybe :: CShort -> Maybe Int Source #

bitSize :: CShort -> Int Source #

isSigned :: CShort -> Bool Source #

shiftL :: CShort -> Int -> CShort Source #

unsafeShiftL :: CShort -> Int -> CShort Source #

shiftR :: CShort -> Int -> CShort Source #

unsafeShiftR :: CShort -> Int -> CShort Source #

rotateL :: CShort -> Int -> CShort Source #

rotateR :: CShort -> Int -> CShort Source #

popCount :: CShort -> Int Source #

Bits CSigAtomic Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CSigAtomic -> CSigAtomic -> CSigAtomic Source #

complement :: CSigAtomic -> CSigAtomic Source #

shift :: CSigAtomic -> Int -> CSigAtomic Source #

rotate :: CSigAtomic -> Int -> CSigAtomic Source #

zeroBits :: CSigAtomic Source #

bit :: Int -> CSigAtomic Source #

setBit :: CSigAtomic -> Int -> CSigAtomic Source #

clearBit :: CSigAtomic -> Int -> CSigAtomic Source #

complementBit :: CSigAtomic -> Int -> CSigAtomic Source #

testBit :: CSigAtomic -> Int -> Bool Source #

bitSizeMaybe :: CSigAtomic -> Maybe Int Source #

bitSize :: CSigAtomic -> Int Source #

isSigned :: CSigAtomic -> Bool Source #

shiftL :: CSigAtomic -> Int -> CSigAtomic Source #

unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic Source #

shiftR :: CSigAtomic -> Int -> CSigAtomic Source #

unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic Source #

rotateL :: CSigAtomic -> Int -> CSigAtomic Source #

rotateR :: CSigAtomic -> Int -> CSigAtomic Source #

popCount :: CSigAtomic -> Int Source #

Bits CSize Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CSize -> CSize -> CSize Source #

complement :: CSize -> CSize Source #

shift :: CSize -> Int -> CSize Source #

rotate :: CSize -> Int -> CSize Source #

zeroBits :: CSize Source #

bit :: Int -> CSize Source #

setBit :: CSize -> Int -> CSize Source #

clearBit :: CSize -> Int -> CSize Source #

complementBit :: CSize -> Int -> CSize Source #

testBit :: CSize -> Int -> Bool Source #

bitSizeMaybe :: CSize -> Maybe Int Source #

bitSize :: CSize -> Int Source #

isSigned :: CSize -> Bool Source #

shiftL :: CSize -> Int -> CSize Source #

unsafeShiftL :: CSize -> Int -> CSize Source #

shiftR :: CSize -> Int -> CSize Source #

unsafeShiftR :: CSize -> Int -> CSize Source #

rotateL :: CSize -> Int -> CSize Source #

rotateR :: CSize -> Int -> CSize Source #

popCount :: CSize -> Int Source #

Bits CUChar Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CUChar -> CUChar -> CUChar Source #

complement :: CUChar -> CUChar Source #

shift :: CUChar -> Int -> CUChar Source #

rotate :: CUChar -> Int -> CUChar Source #

zeroBits :: CUChar Source #

bit :: Int -> CUChar Source #

setBit :: CUChar -> Int -> CUChar Source #

clearBit :: CUChar -> Int -> CUChar Source #

complementBit :: CUChar -> Int -> CUChar Source #

testBit :: CUChar -> Int -> Bool Source #

bitSizeMaybe :: CUChar -> Maybe Int Source #

bitSize :: CUChar -> Int Source #

isSigned :: CUChar -> Bool Source #

shiftL :: CUChar -> Int -> CUChar Source #

unsafeShiftL :: CUChar -> Int -> CUChar Source #

shiftR :: CUChar -> Int -> CUChar Source #

unsafeShiftR :: CUChar -> Int -> CUChar Source #

rotateL :: CUChar -> Int -> CUChar Source #

rotateR :: CUChar -> Int -> CUChar Source #

popCount :: CUChar -> Int Source #

Bits CUInt Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CUInt -> CUInt -> CUInt Source #

complement :: CUInt -> CUInt Source #

shift :: CUInt -> Int -> CUInt Source #

rotate :: CUInt -> Int -> CUInt Source #

zeroBits :: CUInt Source #

bit :: Int -> CUInt Source #

setBit :: CUInt -> Int -> CUInt Source #

clearBit :: CUInt -> Int -> CUInt Source #

complementBit :: CUInt -> Int -> CUInt Source #

testBit :: CUInt -> Int -> Bool Source #

bitSizeMaybe :: CUInt -> Maybe Int Source #

bitSize :: CUInt -> Int Source #

isSigned :: CUInt -> Bool Source #

shiftL :: CUInt -> Int -> CUInt Source #

unsafeShiftL :: CUInt -> Int -> CUInt Source #

shiftR :: CUInt -> Int -> CUInt Source #

unsafeShiftR :: CUInt -> Int -> CUInt Source #

rotateL :: CUInt -> Int -> CUInt Source #

rotateR :: CUInt -> Int -> CUInt Source #

popCount :: CUInt -> Int Source #

Bits CUIntMax Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CUIntMax -> CUIntMax -> CUIntMax Source #

complement :: CUIntMax -> CUIntMax Source #

shift :: CUIntMax -> Int -> CUIntMax Source #

rotate :: CUIntMax -> Int -> CUIntMax Source #

zeroBits :: CUIntMax Source #

bit :: Int -> CUIntMax Source #

setBit :: CUIntMax -> Int -> CUIntMax Source #

clearBit :: CUIntMax -> Int -> CUIntMax Source #

complementBit :: CUIntMax -> Int -> CUIntMax Source #

testBit :: CUIntMax -> Int -> Bool Source #

bitSizeMaybe :: CUIntMax -> Maybe Int Source #

bitSize :: CUIntMax -> Int Source #

isSigned :: CUIntMax -> Bool Source #

shiftL :: CUIntMax -> Int -> CUIntMax Source #

unsafeShiftL :: CUIntMax -> Int -> CUIntMax Source #

shiftR :: CUIntMax -> Int -> CUIntMax Source #

unsafeShiftR :: CUIntMax -> Int -> CUIntMax Source #

rotateL :: CUIntMax -> Int -> CUIntMax Source #

rotateR :: CUIntMax -> Int -> CUIntMax Source #

popCount :: CUIntMax -> Int Source #

Bits CUIntPtr Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CUIntPtr -> CUIntPtr -> CUIntPtr Source #

complement :: CUIntPtr -> CUIntPtr Source #

shift :: CUIntPtr -> Int -> CUIntPtr Source #

rotate :: CUIntPtr -> Int -> CUIntPtr Source #

zeroBits :: CUIntPtr Source #

bit :: Int -> CUIntPtr Source #

setBit :: CUIntPtr -> Int -> CUIntPtr Source #

clearBit :: CUIntPtr -> Int -> CUIntPtr Source #

complementBit :: CUIntPtr -> Int -> CUIntPtr Source #

testBit :: CUIntPtr -> Int -> Bool Source #

bitSizeMaybe :: CUIntPtr -> Maybe Int Source #

bitSize :: CUIntPtr -> Int Source #

isSigned :: CUIntPtr -> Bool Source #

shiftL :: CUIntPtr -> Int -> CUIntPtr Source #

unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr Source #

shiftR :: CUIntPtr -> Int -> CUIntPtr Source #

unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr Source #

rotateL :: CUIntPtr -> Int -> CUIntPtr Source #

rotateR :: CUIntPtr -> Int -> CUIntPtr Source #

popCount :: CUIntPtr -> Int Source #

Bits CULLong Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CULLong -> CULLong -> CULLong Source #

complement :: CULLong -> CULLong Source #

shift :: CULLong -> Int -> CULLong Source #

rotate :: CULLong -> Int -> CULLong Source #

zeroBits :: CULLong Source #

bit :: Int -> CULLong Source #

setBit :: CULLong -> Int -> CULLong Source #

clearBit :: CULLong -> Int -> CULLong Source #

complementBit :: CULLong -> Int -> CULLong Source #

testBit :: CULLong -> Int -> Bool Source #

bitSizeMaybe :: CULLong -> Maybe Int Source #

bitSize :: CULLong -> Int Source #

isSigned :: CULLong -> Bool Source #

shiftL :: CULLong -> Int -> CULLong Source #

unsafeShiftL :: CULLong -> Int -> CULLong Source #

shiftR :: CULLong -> Int -> CULLong Source #

unsafeShiftR :: CULLong -> Int -> CULLong Source #

rotateL :: CULLong -> Int -> CULLong Source #

rotateR :: CULLong -> Int -> CULLong Source #

popCount :: CULLong -> Int Source #

Bits CULong Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CULong -> CULong -> CULong Source #

complement :: CULong -> CULong Source #

shift :: CULong -> Int -> CULong Source #

rotate :: CULong -> Int -> CULong Source #

zeroBits :: CULong Source #

bit :: Int -> CULong Source #

setBit :: CULong -> Int -> CULong Source #

clearBit :: CULong -> Int -> CULong Source #

complementBit :: CULong -> Int -> CULong Source #

testBit :: CULong -> Int -> Bool Source #

bitSizeMaybe :: CULong -> Maybe Int Source #

bitSize :: CULong -> Int Source #

isSigned :: CULong -> Bool Source #

shiftL :: CULong -> Int -> CULong Source #

unsafeShiftL :: CULong -> Int -> CULong Source #

shiftR :: CULong -> Int -> CULong Source #

unsafeShiftR :: CULong -> Int -> CULong Source #

rotateL :: CULong -> Int -> CULong Source #

rotateR :: CULong -> Int -> CULong Source #

popCount :: CULong -> Int Source #

Bits CUShort Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CUShort -> CUShort -> CUShort Source #

complement :: CUShort -> CUShort Source #

shift :: CUShort -> Int -> CUShort Source #

rotate :: CUShort -> Int -> CUShort Source #

zeroBits :: CUShort Source #

bit :: Int -> CUShort Source #

setBit :: CUShort -> Int -> CUShort Source #

clearBit :: CUShort -> Int -> CUShort Source #

complementBit :: CUShort -> Int -> CUShort Source #

testBit :: CUShort -> Int -> Bool Source #

bitSizeMaybe :: CUShort -> Maybe Int Source #

bitSize :: CUShort -> Int Source #

isSigned :: CUShort -> Bool Source #

shiftL :: CUShort -> Int -> CUShort Source #

unsafeShiftL :: CUShort -> Int -> CUShort Source #

shiftR :: CUShort -> Int -> CUShort Source #

unsafeShiftR :: CUShort -> Int -> CUShort Source #

rotateL :: CUShort -> Int -> CUShort Source #

rotateR :: CUShort -> Int -> CUShort Source #

popCount :: CUShort -> Int Source #

Bits CWchar Source #

Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CWchar -> CWchar -> CWchar Source #

complement :: CWchar -> CWchar Source #

shift :: CWchar -> Int -> CWchar Source #

rotate :: CWchar -> Int -> CWchar Source #

zeroBits :: CWchar Source #

bit :: Int -> CWchar Source #

setBit :: CWchar -> Int -> CWchar Source #

clearBit :: CWchar -> Int -> CWchar Source #

complementBit :: CWchar -> Int -> CWchar Source #

testBit :: CWchar -> Int -> Bool Source #

bitSizeMaybe :: CWchar -> Maybe Int Source #

bitSize :: CWchar -> Int Source #

isSigned :: CWchar -> Bool Source #

shiftL :: CWchar -> Int -> CWchar Source #

unsafeShiftL :: CWchar -> Int -> CWchar Source #

shiftR :: CWchar -> Int -> CWchar Source #

unsafeShiftR :: CWchar -> Int -> CWchar Source #

rotateL :: CWchar -> Int -> CWchar Source #

rotateR :: CWchar -> Int -> CWchar Source #

popCount :: CWchar -> Int Source #

Bits IntPtr Source #

Instance details

Defined in Foreign.Ptr

Methods

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

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

xor :: IntPtr -> IntPtr -> IntPtr Source #

complement :: IntPtr -> IntPtr Source #

shift :: IntPtr -> Int -> IntPtr Source #

rotate :: IntPtr -> Int -> IntPtr Source #

zeroBits :: IntPtr Source #

bit :: Int -> IntPtr Source #

setBit :: IntPtr -> Int -> IntPtr Source #

clearBit :: IntPtr -> Int -> IntPtr Source #

complementBit :: IntPtr -> Int -> IntPtr Source #

testBit :: IntPtr -> Int -> Bool Source #

bitSizeMaybe :: IntPtr -> Maybe Int Source #

bitSize :: IntPtr -> Int Source #

isSigned :: IntPtr -> Bool Source #

shiftL :: IntPtr -> Int -> IntPtr Source #

unsafeShiftL :: IntPtr -> Int -> IntPtr Source #

shiftR :: IntPtr -> Int -> IntPtr Source #

unsafeShiftR :: IntPtr -> Int -> IntPtr Source #

rotateL :: IntPtr -> Int -> IntPtr Source #

rotateR :: IntPtr -> Int -> IntPtr Source #

popCount :: IntPtr -> Int Source #

Bits WordPtr Source #

Instance details

Defined in Foreign.Ptr

Methods

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

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

xor :: WordPtr -> WordPtr -> WordPtr Source #

complement :: WordPtr -> WordPtr Source #

shift :: WordPtr -> Int -> WordPtr Source #

rotate :: WordPtr -> Int -> WordPtr Source #

zeroBits :: WordPtr Source #

bit :: Int -> WordPtr Source #

setBit :: WordPtr -> Int -> WordPtr Source #

clearBit :: WordPtr -> Int -> WordPtr Source #

complementBit :: WordPtr -> Int -> WordPtr Source #

testBit :: WordPtr -> Int -> Bool Source #

bitSizeMaybe :: WordPtr -> Maybe Int Source #

bitSize :: WordPtr -> Int Source #

isSigned :: WordPtr -> Bool Source #

shiftL :: WordPtr -> Int -> WordPtr Source #

unsafeShiftL :: WordPtr -> Int -> WordPtr Source #

shiftR :: WordPtr -> Int -> WordPtr Source #

unsafeShiftR :: WordPtr -> Int -> WordPtr Source #

rotateL :: WordPtr -> Int -> WordPtr Source #

rotateR :: WordPtr -> Int -> WordPtr Source #

popCount :: WordPtr -> Int Source #

Bits Int16 Source #

Since: base-2.1

Instance details

Defined in GHC.Int

Methods

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

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

xor :: Int16 -> Int16 -> Int16 Source #

complement :: Int16 -> Int16 Source #

shift :: Int16 -> Int -> Int16 Source #

rotate :: Int16 -> Int -> Int16 Source #

zeroBits :: Int16 Source #

bit :: Int -> Int16 Source #

setBit :: Int16 -> Int -> Int16 Source #

clearBit :: Int16 -> Int -> Int16 Source #

complementBit :: Int16 -> Int -> Int16 Source #

testBit :: Int16 -> Int -> Bool Source #

bitSizeMaybe :: Int16 -> Maybe Int Source #

bitSize :: Int16 -> Int Source #

isSigned :: Int16 -> Bool Source #

shiftL :: Int16 -> Int -> Int16 Source #

unsafeShiftL :: Int16 -> Int -> Int16 Source #

shiftR :: Int16 -> Int -> Int16 Source #

unsafeShiftR :: Int16 -> Int -> Int16 Source #

rotateL :: Int16 -> Int -> Int16 Source #

rotateR :: Int16 -> Int -> Int16 Source #

popCount :: Int16 -> Int Source #

Bits Int32 Source #

Since: base-2.1

Instance details

Defined in GHC.Int

Methods

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

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

xor :: Int32 -> Int32 -> Int32 Source #

complement :: Int32 -> Int32 Source #

shift :: Int32 -> Int -> Int32 Source #

rotate :: Int32 -> Int -> Int32 Source #

zeroBits :: Int32 Source #

bit :: Int -> Int32 Source #

setBit :: Int32 -> Int -> Int32 Source #

clearBit :: Int32 -> Int -> Int32 Source #

complementBit :: Int32 -> Int -> Int32 Source #

testBit :: Int32 -> Int -> Bool Source #

bitSizeMaybe :: Int32 -> Maybe Int Source #

bitSize :: Int32 -> Int Source #

isSigned :: Int32 -> Bool Source #

shiftL :: Int32 -> Int -> Int32 Source #

unsafeShiftL :: Int32 -> Int -> Int32 Source #

shiftR :: Int32 -> Int -> Int32 Source #

unsafeShiftR :: Int32 -> Int -> Int32 Source #

rotateL :: Int32 -> Int -> Int32 Source #

rotateR :: Int32 -> Int -> Int32 Source #

popCount :: Int32 -> Int Source #

Bits Int64 Source #

Since: base-2.1

Instance details

Defined in GHC.Int

Methods

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

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

xor :: Int64 -> Int64 -> Int64 Source #

complement :: Int64 -> Int64 Source #

shift :: Int64 -> Int -> Int64 Source #

rotate :: Int64 -> Int -> Int64 Source #

zeroBits :: Int64 Source #

bit :: Int -> Int64 Source #

setBit :: Int64 -> Int -> Int64 Source #

clearBit :: Int64 -> Int -> Int64 Source #

complementBit :: Int64 -> Int -> Int64 Source #

testBit :: Int64 -> Int -> Bool Source #

bitSizeMaybe :: Int64 -> Maybe Int Source #

bitSize :: Int64 -> Int Source #

isSigned :: Int64 -> Bool Source #

shiftL :: Int64 -> Int -> Int64 Source #

unsafeShiftL :: Int64 -> Int -> Int64 Source #

shiftR :: Int64 -> Int -> Int64 Source #

unsafeShiftR :: Int64 -> Int -> Int64 Source #

rotateL :: Int64 -> Int -> Int64 Source #

rotateR :: Int64 -> Int -> Int64 Source #

popCount :: Int64 -> Int Source #

Bits Int8 Source #

Since: base-2.1

Instance details

Defined in GHC.Int

Methods

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

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

xor :: Int8 -> Int8 -> Int8 Source #

complement :: Int8 -> Int8 Source #

shift :: Int8 -> Int -> Int8 Source #

rotate :: Int8 -> Int -> Int8 Source #

zeroBits :: Int8 Source #

bit :: Int -> Int8 Source #

setBit :: Int8 -> Int -> Int8 Source #

clearBit :: Int8 -> Int -> Int8 Source #

complementBit :: Int8 -> Int -> Int8 Source #

testBit :: Int8 -> Int -> Bool Source #

bitSizeMaybe :: Int8 -> Maybe Int Source #

bitSize :: Int8 -> Int Source #

isSigned :: Int8 -> Bool Source #

shiftL :: Int8 -> Int -> Int8 Source #

unsafeShiftL :: Int8 -> Int -> Int8 Source #

shiftR :: Int8 -> Int -> Int8 Source #

unsafeShiftR :: Int8 -> Int -> Int8 Source #

rotateL :: Int8 -> Int -> Int8 Source #

rotateR :: Int8 -> Int -> Int8 Source #

popCount :: Int8 -> Int Source #

Bits Word16 Source #

Since: base-2.1

Instance details

Defined in GHC.Word

Methods

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

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

xor :: Word16 -> Word16 -> Word16 Source #

complement :: Word16 -> Word16 Source #

shift :: Word16 -> Int -> Word16 Source #

rotate :: Word16 -> Int -> Word16 Source #

zeroBits :: Word16 Source #

bit :: Int -> Word16 Source #

setBit :: Word16 -> Int -> Word16 Source #

clearBit :: Word16 -> Int -> Word16 Source #

complementBit :: Word16 -> Int -> Word16 Source #

testBit :: Word16 -> Int -> Bool Source #

bitSizeMaybe :: Word16 -> Maybe Int Source #

bitSize :: Word16 -> Int Source #

isSigned :: Word16 -> Bool Source #

shiftL :: Word16 -> Int -> Word16 Source #

unsafeShiftL :: Word16 -> Int -> Word16 Source #

shiftR :: Word16 -> Int -> Word16 Source #

unsafeShiftR :: Word16 -> Int -> Word16 Source #

rotateL :: Word16 -> Int -> Word16 Source #

rotateR :: Word16 -> Int -> Word16 Source #

popCount :: Word16 -> Int Source #

Bits Word32 Source #

Since: base-2.1

Instance details

Defined in GHC.Word

Methods

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

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

xor :: Word32 -> Word32 -> Word32 Source #

complement :: Word32 -> Word32 Source #

shift :: Word32 -> Int -> Word32 Source #

rotate :: Word32 -> Int -> Word32 Source #

zeroBits :: Word32 Source #

bit :: Int -> Word32 Source #

setBit :: Word32 -> Int -> Word32 Source #

clearBit :: Word32 -> Int -> Word32 Source #

complementBit :: Word32 -> Int -> Word32 Source #

testBit :: Word32 -> Int -> Bool Source #

bitSizeMaybe :: Word32 -> Maybe Int Source #

bitSize :: Word32 -> Int Source #

isSigned :: Word32 -> Bool Source #

shiftL :: Word32 -> Int -> Word32 Source #

unsafeShiftL :: Word32 -> Int -> Word32 Source #

shiftR :: Word32 -> Int -> Word32 Source #

unsafeShiftR :: Word32 -> Int -> Word32 Source #

rotateL :: Word32 -> Int -> Word32 Source #

rotateR :: Word32 -> Int -> Word32 Source #

popCount :: Word32 -> Int Source #

Bits Word64 Source #

Since: base-2.1

Instance details

Defined in GHC.Word

Methods

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

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

xor :: Word64 -> Word64 -> Word64 Source #

complement :: Word64 -> Word64 Source #

shift :: Word64 -> Int -> Word64 Source #

rotate :: Word64 -> Int -> Word64 Source #

zeroBits :: Word64 Source #

bit :: Int -> Word64 Source #

setBit :: Word64 -> Int -> Word64 Source #

clearBit :: Word64 -> Int -> Word64 Source #

complementBit :: Word64 -> Int -> Word64 Source #

testBit :: Word64 -> Int -> Bool Source #

bitSizeMaybe :: Word64 -> Maybe Int Source #

bitSize :: Word64 -> Int Source #

isSigned :: Word64 -> Bool Source #

shiftL :: Word64 -> Int -> Word64 Source #

unsafeShiftL :: Word64 -> Int -> Word64 Source #

shiftR :: Word64 -> Int -> Word64 Source #

unsafeShiftR :: Word64 -> Int -> Word64 Source #

rotateL :: Word64 -> Int -> Word64 Source #

rotateR :: Word64 -> Int -> Word64 Source #

popCount :: Word64 -> Int Source #

Bits Word8 Source #

Since: base-2.1

Instance details

Defined in GHC.Word

Methods

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

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

xor :: Word8 -> Word8 -> Word8 Source #

complement :: Word8 -> Word8 Source #

shift :: Word8 -> Int -> Word8 Source #

rotate :: Word8 -> Int -> Word8 Source #

zeroBits :: Word8 Source #

bit :: Int -> Word8 Source #

setBit :: Word8 -> Int -> Word8 Source #

clearBit :: Word8 -> Int -> Word8 Source #

complementBit :: Word8 -> Int -> Word8 Source #

testBit :: Word8 -> Int -> Bool Source #

bitSizeMaybe :: Word8 -> Maybe Int Source #

bitSize :: Word8 -> Int Source #

isSigned :: Word8 -> Bool Source #

shiftL :: Word8 -> Int -> Word8 Source #

unsafeShiftL :: Word8 -> Int -> Word8 Source #

shiftR :: Word8 -> Int -> Word8 Source #

unsafeShiftR :: Word8 -> Int -> Word8 Source #

rotateL :: Word8 -> Int -> Word8 Source #

rotateR :: Word8 -> Int -> Word8 Source #

popCount :: Word8 -> Int Source #

Bits CBlkCnt Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source #

(.|.) :: CBlkCnt -> CBlkCnt -> CBlkCnt Source #

xor :: CBlkCnt -> CBlkCnt -> CBlkCnt Source #

complement :: CBlkCnt -> CBlkCnt Source #

shift :: CBlkCnt -> Int -> CBlkCnt Source #

rotate :: CBlkCnt -> Int -> CBlkCnt Source #

zeroBits :: CBlkCnt Source #

bit :: Int -> CBlkCnt Source #

setBit :: CBlkCnt -> Int -> CBlkCnt Source #

clearBit :: CBlkCnt -> Int -> CBlkCnt Source #

complementBit :: CBlkCnt -> Int -> CBlkCnt Source #

testBit :: CBlkCnt -> Int -> Bool Source #

bitSizeMaybe :: CBlkCnt -> Maybe Int Source #

bitSize :: CBlkCnt -> Int Source #

isSigned :: CBlkCnt -> Bool Source #

shiftL :: CBlkCnt -> Int -> CBlkCnt Source #

unsafeShiftL :: CBlkCnt -> Int -> CBlkCnt Source #

shiftR :: CBlkCnt -> Int -> CBlkCnt Source #

unsafeShiftR :: CBlkCnt -> Int -> CBlkCnt Source #

rotateL :: CBlkCnt -> Int -> CBlkCnt Source #

rotateR :: CBlkCnt -> Int -> CBlkCnt Source #

popCount :: CBlkCnt -> Int Source #

Bits CBlkSize Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CBlkSize -> CBlkSize -> CBlkSize Source #

(.|.) :: CBlkSize -> CBlkSize -> CBlkSize Source #

xor :: CBlkSize -> CBlkSize -> CBlkSize Source #

complement :: CBlkSize -> CBlkSize Source #

shift :: CBlkSize -> Int -> CBlkSize Source #

rotate :: CBlkSize -> Int -> CBlkSize Source #

zeroBits :: CBlkSize Source #

bit :: Int -> CBlkSize Source #

setBit :: CBlkSize -> Int -> CBlkSize Source #

clearBit :: CBlkSize -> Int -> CBlkSize Source #

complementBit :: CBlkSize -> Int -> CBlkSize Source #

testBit :: CBlkSize -> Int -> Bool Source #

bitSizeMaybe :: CBlkSize -> Maybe Int Source #

bitSize :: CBlkSize -> Int Source #

isSigned :: CBlkSize -> Bool Source #

shiftL :: CBlkSize -> Int -> CBlkSize Source #

unsafeShiftL :: CBlkSize -> Int -> CBlkSize Source #

shiftR :: CBlkSize -> Int -> CBlkSize Source #

unsafeShiftR :: CBlkSize -> Int -> CBlkSize Source #

rotateL :: CBlkSize -> Int -> CBlkSize Source #

rotateR :: CBlkSize -> Int -> CBlkSize Source #

popCount :: CBlkSize -> Int Source #

Bits CClockId Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CClockId -> CClockId -> CClockId Source #

(.|.) :: CClockId -> CClockId -> CClockId Source #

xor :: CClockId -> CClockId -> CClockId Source #

complement :: CClockId -> CClockId Source #

shift :: CClockId -> Int -> CClockId Source #

rotate :: CClockId -> Int -> CClockId Source #

zeroBits :: CClockId Source #

bit :: Int -> CClockId Source #

setBit :: CClockId -> Int -> CClockId Source #

clearBit :: CClockId -> Int -> CClockId Source #

complementBit :: CClockId -> Int -> CClockId Source #

testBit :: CClockId -> Int -> Bool Source #

bitSizeMaybe :: CClockId -> Maybe Int Source #

bitSize :: CClockId -> Int Source #

isSigned :: CClockId -> Bool Source #

shiftL :: CClockId -> Int -> CClockId Source #

unsafeShiftL :: CClockId -> Int -> CClockId Source #

shiftR :: CClockId -> Int -> CClockId Source #

unsafeShiftR :: CClockId -> Int -> CClockId Source #

rotateL :: CClockId -> Int -> CClockId Source #

rotateR :: CClockId -> Int -> CClockId Source #

popCount :: CClockId -> Int Source #

Bits CDev Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CDev -> CDev -> CDev Source #

complement :: CDev -> CDev Source #

shift :: CDev -> Int -> CDev Source #

rotate :: CDev -> Int -> CDev Source #

zeroBits :: CDev Source #

bit :: Int -> CDev Source #

setBit :: CDev -> Int -> CDev Source #

clearBit :: CDev -> Int -> CDev Source #

complementBit :: CDev -> Int -> CDev Source #

testBit :: CDev -> Int -> Bool Source #

bitSizeMaybe :: CDev -> Maybe Int Source #

bitSize :: CDev -> Int Source #

isSigned :: CDev -> Bool Source #

shiftL :: CDev -> Int -> CDev Source #

unsafeShiftL :: CDev -> Int -> CDev Source #

shiftR :: CDev -> Int -> CDev Source #

unsafeShiftR :: CDev -> Int -> CDev Source #

rotateL :: CDev -> Int -> CDev Source #

rotateR :: CDev -> Int -> CDev Source #

popCount :: CDev -> Int Source #

Bits CFsBlkCnt Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source #

(.|.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source #

xor :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt Source #

complement :: CFsBlkCnt -> CFsBlkCnt Source #

shift :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

rotate :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

zeroBits :: CFsBlkCnt Source #

bit :: Int -> CFsBlkCnt Source #

setBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

clearBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

complementBit :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

testBit :: CFsBlkCnt -> Int -> Bool Source #

bitSizeMaybe :: CFsBlkCnt -> Maybe Int Source #

bitSize :: CFsBlkCnt -> Int Source #

isSigned :: CFsBlkCnt -> Bool Source #

shiftL :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

unsafeShiftL :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

shiftR :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

unsafeShiftR :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

rotateL :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

rotateR :: CFsBlkCnt -> Int -> CFsBlkCnt Source #

popCount :: CFsBlkCnt -> Int Source #

Bits CFsFilCnt Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source #

(.|.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source #

xor :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt Source #

complement :: CFsFilCnt -> CFsFilCnt Source #

shift :: CFsFilCnt -> Int -> CFsFilCnt Source #

rotate :: CFsFilCnt -> Int -> CFsFilCnt Source #

zeroBits :: CFsFilCnt Source #

bit :: Int -> CFsFilCnt Source #

setBit :: CFsFilCnt -> Int -> CFsFilCnt Source #

clearBit :: CFsFilCnt -> Int -> CFsFilCnt Source #

complementBit :: CFsFilCnt -> Int -> CFsFilCnt Source #

testBit :: CFsFilCnt -> Int -> Bool Source #

bitSizeMaybe :: CFsFilCnt -> Maybe Int Source #

bitSize :: CFsFilCnt -> Int Source #

isSigned :: CFsFilCnt -> Bool Source #

shiftL :: CFsFilCnt -> Int -> CFsFilCnt Source #

unsafeShiftL :: CFsFilCnt -> Int -> CFsFilCnt Source #

shiftR :: CFsFilCnt -> Int -> CFsFilCnt Source #

unsafeShiftR :: CFsFilCnt -> Int -> CFsFilCnt Source #

rotateL :: CFsFilCnt -> Int -> CFsFilCnt Source #

rotateR :: CFsFilCnt -> Int -> CFsFilCnt Source #

popCount :: CFsFilCnt -> Int Source #

Bits CGid Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CGid -> CGid -> CGid Source #

complement :: CGid -> CGid Source #

shift :: CGid -> Int -> CGid Source #

rotate :: CGid -> Int -> CGid Source #

zeroBits :: CGid Source #

bit :: Int -> CGid Source #

setBit :: CGid -> Int -> CGid Source #

clearBit :: CGid -> Int -> CGid Source #

complementBit :: CGid -> Int -> CGid Source #

testBit :: CGid -> Int -> Bool Source #

bitSizeMaybe :: CGid -> Maybe Int Source #

bitSize :: CGid -> Int Source #

isSigned :: CGid -> Bool Source #

shiftL :: CGid -> Int -> CGid Source #

unsafeShiftL :: CGid -> Int -> CGid Source #

shiftR :: CGid -> Int -> CGid Source #

unsafeShiftR :: CGid -> Int -> CGid Source #

rotateL :: CGid -> Int -> CGid Source #

rotateR :: CGid -> Int -> CGid Source #

popCount :: CGid -> Int Source #

Bits CId Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CId -> CId -> CId Source #

(.|.) :: CId -> CId -> CId Source #

xor :: CId -> CId -> CId Source #

complement :: CId -> CId Source #

shift :: CId -> Int -> CId Source #

rotate :: CId -> Int -> CId Source #

zeroBits :: CId Source #

bit :: Int -> CId Source #

setBit :: CId -> Int -> CId Source #

clearBit :: CId -> Int -> CId Source #

complementBit :: CId -> Int -> CId Source #

testBit :: CId -> Int -> Bool Source #

bitSizeMaybe :: CId -> Maybe Int Source #

bitSize :: CId -> Int Source #

isSigned :: CId -> Bool Source #

shiftL :: CId -> Int -> CId Source #

unsafeShiftL :: CId -> Int -> CId Source #

shiftR :: CId -> Int -> CId Source #

unsafeShiftR :: CId -> Int -> CId Source #

rotateL :: CId -> Int -> CId Source #

rotateR :: CId -> Int -> CId Source #

popCount :: CId -> Int Source #

Bits CIno Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CIno -> CIno -> CIno Source #

complement :: CIno -> CIno Source #

shift :: CIno -> Int -> CIno Source #

rotate :: CIno -> Int -> CIno Source #

zeroBits :: CIno Source #

bit :: Int -> CIno Source #

setBit :: CIno -> Int -> CIno Source #

clearBit :: CIno -> Int -> CIno Source #

complementBit :: CIno -> Int -> CIno Source #

testBit :: CIno -> Int -> Bool Source #

bitSizeMaybe :: CIno -> Maybe Int Source #

bitSize :: CIno -> Int Source #

isSigned :: CIno -> Bool Source #

shiftL :: CIno -> Int -> CIno Source #

unsafeShiftL :: CIno -> Int -> CIno Source #

shiftR :: CIno -> Int -> CIno Source #

unsafeShiftR :: CIno -> Int -> CIno Source #

rotateL :: CIno -> Int -> CIno Source #

rotateR :: CIno -> Int -> CIno Source #

popCount :: CIno -> Int Source #

Bits CKey Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CKey -> CKey -> CKey Source #

(.|.) :: CKey -> CKey -> CKey Source #

xor :: CKey -> CKey -> CKey Source #

complement :: CKey -> CKey Source #

shift :: CKey -> Int -> CKey Source #

rotate :: CKey -> Int -> CKey Source #

zeroBits :: CKey Source #

bit :: Int -> CKey Source #

setBit :: CKey -> Int -> CKey Source #

clearBit :: CKey -> Int -> CKey Source #

complementBit :: CKey -> Int -> CKey Source #

testBit :: CKey -> Int -> Bool Source #

bitSizeMaybe :: CKey -> Maybe Int Source #

bitSize :: CKey -> Int Source #

isSigned :: CKey -> Bool Source #

shiftL :: CKey -> Int -> CKey Source #

unsafeShiftL :: CKey -> Int -> CKey Source #

shiftR :: CKey -> Int -> CKey Source #

unsafeShiftR :: CKey -> Int -> CKey Source #

rotateL :: CKey -> Int -> CKey Source #

rotateR :: CKey -> Int -> CKey Source #

popCount :: CKey -> Int Source #

Bits CMode Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CMode -> CMode -> CMode Source #

complement :: CMode -> CMode Source #

shift :: CMode -> Int -> CMode Source #

rotate :: CMode -> Int -> CMode Source #

zeroBits :: CMode Source #

bit :: Int -> CMode Source #

setBit :: CMode -> Int -> CMode Source #

clearBit :: CMode -> Int -> CMode Source #

complementBit :: CMode -> Int -> CMode Source #

testBit :: CMode -> Int -> Bool Source #

bitSizeMaybe :: CMode -> Maybe Int Source #

bitSize :: CMode -> Int Source #

isSigned :: CMode -> Bool Source #

shiftL :: CMode -> Int -> CMode Source #

unsafeShiftL :: CMode -> Int -> CMode Source #

shiftR :: CMode -> Int -> CMode Source #

unsafeShiftR :: CMode -> Int -> CMode Source #

rotateL :: CMode -> Int -> CMode Source #

rotateR :: CMode -> Int -> CMode Source #

popCount :: CMode -> Int Source #

Bits CNfds Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CNfds -> CNfds -> CNfds Source #

(.|.) :: CNfds -> CNfds -> CNfds Source #

xor :: CNfds -> CNfds -> CNfds Source #

complement :: CNfds -> CNfds Source #

shift :: CNfds -> Int -> CNfds Source #

rotate :: CNfds -> Int -> CNfds Source #

zeroBits :: CNfds Source #

bit :: Int -> CNfds Source #

setBit :: CNfds -> Int -> CNfds Source #

clearBit :: CNfds -> Int -> CNfds Source #

complementBit :: CNfds -> Int -> CNfds Source #

testBit :: CNfds -> Int -> Bool Source #

bitSizeMaybe :: CNfds -> Maybe Int Source #

bitSize :: CNfds -> Int Source #

isSigned :: CNfds -> Bool Source #

shiftL :: CNfds -> Int -> CNfds Source #

unsafeShiftL :: CNfds -> Int -> CNfds Source #

shiftR :: CNfds -> Int -> CNfds Source #

unsafeShiftR :: CNfds -> Int -> CNfds Source #

rotateL :: CNfds -> Int -> CNfds Source #

rotateR :: CNfds -> Int -> CNfds Source #

popCount :: CNfds -> Int Source #

Bits CNlink Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CNlink -> CNlink -> CNlink Source #

complement :: CNlink -> CNlink Source #

shift :: CNlink -> Int -> CNlink Source #

rotate :: CNlink -> Int -> CNlink Source #

zeroBits :: CNlink Source #

bit :: Int -> CNlink Source #

setBit :: CNlink -> Int -> CNlink Source #

clearBit :: CNlink -> Int -> CNlink Source #

complementBit :: CNlink -> Int -> CNlink Source #

testBit :: CNlink -> Int -> Bool Source #

bitSizeMaybe :: CNlink -> Maybe Int Source #

bitSize :: CNlink -> Int Source #

isSigned :: CNlink -> Bool Source #

shiftL :: CNlink -> Int -> CNlink Source #

unsafeShiftL :: CNlink -> Int -> CNlink Source #

shiftR :: CNlink -> Int -> CNlink Source #

unsafeShiftR :: CNlink -> Int -> CNlink Source #

rotateL :: CNlink -> Int -> CNlink Source #

rotateR :: CNlink -> Int -> CNlink Source #

popCount :: CNlink -> Int Source #

Bits COff Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: COff -> COff -> COff Source #

complement :: COff -> COff Source #

shift :: COff -> Int -> COff Source #

rotate :: COff -> Int -> COff Source #

zeroBits :: COff Source #

bit :: Int -> COff Source #

setBit :: COff -> Int -> COff Source #

clearBit :: COff -> Int -> COff Source #

complementBit :: COff -> Int -> COff Source #

testBit :: COff -> Int -> Bool Source #

bitSizeMaybe :: COff -> Maybe Int Source #

bitSize :: COff -> Int Source #

isSigned :: COff -> Bool Source #

shiftL :: COff -> Int -> COff Source #

unsafeShiftL :: COff -> Int -> COff Source #

shiftR :: COff -> Int -> COff Source #

unsafeShiftR :: COff -> Int -> COff Source #

rotateL :: COff -> Int -> COff Source #

rotateR :: COff -> Int -> COff Source #

popCount :: COff -> Int Source #

Bits CPid Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CPid -> CPid -> CPid Source #

complement :: CPid -> CPid Source #

shift :: CPid -> Int -> CPid Source #

rotate :: CPid -> Int -> CPid Source #

zeroBits :: CPid Source #

bit :: Int -> CPid Source #

setBit :: CPid -> Int -> CPid Source #

clearBit :: CPid -> Int -> CPid Source #

complementBit :: CPid -> Int -> CPid Source #

testBit :: CPid -> Int -> Bool Source #

bitSizeMaybe :: CPid -> Maybe Int Source #

bitSize :: CPid -> Int Source #

isSigned :: CPid -> Bool Source #

shiftL :: CPid -> Int -> CPid Source #

unsafeShiftL :: CPid -> Int -> CPid Source #

shiftR :: CPid -> Int -> CPid Source #

unsafeShiftR :: CPid -> Int -> CPid Source #

rotateL :: CPid -> Int -> CPid Source #

rotateR :: CPid -> Int -> CPid Source #

popCount :: CPid -> Int Source #

Bits CRLim Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CRLim -> CRLim -> CRLim Source #

complement :: CRLim -> CRLim Source #

shift :: CRLim -> Int -> CRLim Source #

rotate :: CRLim -> Int -> CRLim Source #

zeroBits :: CRLim Source #

bit :: Int -> CRLim Source #

setBit :: CRLim -> Int -> CRLim Source #

clearBit :: CRLim -> Int -> CRLim Source #

complementBit :: CRLim -> Int -> CRLim Source #

testBit :: CRLim -> Int -> Bool Source #

bitSizeMaybe :: CRLim -> Maybe Int Source #

bitSize :: CRLim -> Int Source #

isSigned :: CRLim -> Bool Source #

shiftL :: CRLim -> Int -> CRLim Source #

unsafeShiftL :: CRLim -> Int -> CRLim Source #

shiftR :: CRLim -> Int -> CRLim Source #

unsafeShiftR :: CRLim -> Int -> CRLim Source #

rotateL :: CRLim -> Int -> CRLim Source #

rotateR :: CRLim -> Int -> CRLim Source #

popCount :: CRLim -> Int Source #

Bits CSocklen Source #

Instance details

Defined in System.Posix.Types

Methods

(.&.) :: CSocklen -> CSocklen -> CSocklen Source #

(.|.) :: CSocklen -> CSocklen -> CSocklen Source #

xor :: CSocklen -> CSocklen -> CSocklen Source #

complement :: CSocklen -> CSocklen Source #

shift :: CSocklen -> Int -> CSocklen Source #

rotate :: CSocklen -> Int -> CSocklen Source #

zeroBits :: CSocklen Source #

bit :: Int -> CSocklen Source #

setBit :: CSocklen -> Int -> CSocklen Source #

clearBit :: CSocklen -> Int -> CSocklen Source #

complementBit :: CSocklen -> Int -> CSocklen Source #

testBit :: CSocklen -> Int -> Bool Source #

bitSizeMaybe :: CSocklen -> Maybe Int Source #

bitSize :: CSocklen -> Int Source #

isSigned :: CSocklen -> Bool Source #

shiftL :: CSocklen -> Int -> CSocklen Source #

unsafeShiftL :: CSocklen -> Int -> CSocklen Source #

shiftR :: CSocklen -> Int -> CSocklen Source #

unsafeShiftR :: CSocklen -> Int -> CSocklen Source #

rotateL :: CSocklen -> Int -> CSocklen Source #

rotateR :: CSocklen -> Int -> CSocklen Source #

popCount :: CSocklen -> Int Source #

Bits CSsize Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CSsize -> CSsize -> CSsize Source #

complement :: CSsize -> CSsize Source #

shift :: CSsize -> Int -> CSsize Source #

rotate :: CSsize -> Int -> CSsize Source #

zeroBits :: CSsize Source #

bit :: Int -> CSsize Source #

setBit :: CSsize -> Int -> CSsize Source #

clearBit :: CSsize -> Int -> CSsize Source #

complementBit :: CSsize -> Int -> CSsize Source #

testBit :: CSsize -> Int -> Bool Source #

bitSizeMaybe :: CSsize -> Maybe Int Source #

bitSize :: CSsize -> Int Source #

isSigned :: CSsize -> Bool Source #

shiftL :: CSsize -> Int -> CSsize Source #

unsafeShiftL :: CSsize -> Int -> CSsize Source #

shiftR :: CSsize -> Int -> CSsize Source #

unsafeShiftR :: CSsize -> Int -> CSsize Source #

rotateL :: CSsize -> Int -> CSsize Source #

rotateR :: CSsize -> Int -> CSsize Source #

popCount :: CSsize -> Int Source #

Bits CTcflag Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CTcflag -> CTcflag -> CTcflag Source #

complement :: CTcflag -> CTcflag Source #

shift :: CTcflag -> Int -> CTcflag Source #

rotate :: CTcflag -> Int -> CTcflag Source #

zeroBits :: CTcflag Source #

bit :: Int -> CTcflag Source #

setBit :: CTcflag -> Int -> CTcflag Source #

clearBit :: CTcflag -> Int -> CTcflag Source #

complementBit :: CTcflag -> Int -> CTcflag Source #

testBit :: CTcflag -> Int -> Bool Source #

bitSizeMaybe :: CTcflag -> Maybe Int Source #

bitSize :: CTcflag -> Int Source #

isSigned :: CTcflag -> Bool Source #

shiftL :: CTcflag -> Int -> CTcflag Source #

unsafeShiftL :: CTcflag -> Int -> CTcflag Source #

shiftR :: CTcflag -> Int -> CTcflag Source #

unsafeShiftR :: CTcflag -> Int -> CTcflag Source #

rotateL :: CTcflag -> Int -> CTcflag Source #

rotateR :: CTcflag -> Int -> CTcflag Source #

popCount :: CTcflag -> Int Source #

Bits CUid Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CUid -> CUid -> CUid Source #

complement :: CUid -> CUid Source #

shift :: CUid -> Int -> CUid Source #

rotate :: CUid -> Int -> CUid Source #

zeroBits :: CUid Source #

bit :: Int -> CUid Source #

setBit :: CUid -> Int -> CUid Source #

clearBit :: CUid -> Int -> CUid Source #

complementBit :: CUid -> Int -> CUid Source #

testBit :: CUid -> Int -> Bool Source #

bitSizeMaybe :: CUid -> Maybe Int Source #

bitSize :: CUid -> Int Source #

isSigned :: CUid -> Bool Source #

shiftL :: CUid -> Int -> CUid Source #

unsafeShiftL :: CUid -> Int -> CUid Source #

shiftR :: CUid -> Int -> CUid Source #

unsafeShiftR :: CUid -> Int -> CUid Source #

rotateL :: CUid -> Int -> CUid Source #

rotateR :: CUid -> Int -> CUid Source #

popCount :: CUid -> Int Source #

Bits Fd Source #

Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: Fd -> Fd -> Fd Source #

complement :: Fd -> Fd Source #

shift :: Fd -> Int -> Fd Source #

rotate :: Fd -> Int -> Fd Source #

zeroBits :: Fd Source #

bit :: Int -> Fd Source #

setBit :: Fd -> Int -> Fd Source #

clearBit :: Fd -> Int -> Fd Source #

complementBit :: Fd -> Int -> Fd Source #

testBit :: Fd -> Int -> Bool Source #

bitSizeMaybe :: Fd -> Maybe Int Source #

bitSize :: Fd -> Int Source #

isSigned :: Fd -> Bool Source #

shiftL :: Fd -> Int -> Fd Source #

unsafeShiftL :: Fd -> Int -> Fd Source #

shiftR :: Fd -> Int -> Fd Source #

unsafeShiftR :: Fd -> Int -> Fd Source #

rotateL :: Fd -> Int -> Fd Source #

rotateR :: Fd -> Int -> Fd Source #

popCount :: Fd -> Int Source #

Bits Integer Source #

Since: base-2.1

Instance details

Defined in GHC.Bits

Methods

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

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