foundation-0.0.28: Alternative prelude with batteries and no dependencies
Safe HaskellNone
LanguageHaskell2010

Foundation.Bits

Synopsis

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 #

Methods

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

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

xor :: a -> a -> a #

complement :: a -> a #

shift :: a -> Int -> a #

rotate :: a -> Int -> a #

zeroBits :: a #

bit :: Int -> a #

setBit :: a -> Int -> a #

clearBit :: a -> Int -> a #

complementBit :: a -> Int -> a #

testBit :: a -> Int -> Bool #

bitSizeMaybe :: a -> Maybe Int #

bitSize :: a -> Int #

isSigned :: a -> Bool #

shiftL :: a -> Int -> a #

unsafeShiftL :: a -> Int -> a #

shiftR :: a -> Int -> a #

unsafeShiftR :: a -> Int -> a #

rotateL :: a -> Int -> a #

rotateR :: a -> Int -> a #

popCount :: a -> Int #

Instances

Instances details
Bits Bool 
Instance details

Defined in Data.Bits

Bits Int 
Instance details

Defined in Data.Bits

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 
Instance details

Defined in GHC.Int

Bits Int16 
Instance details

Defined in GHC.Int

Bits Int32 
Instance details

Defined in GHC.Int

Bits Int64 
Instance details

Defined in GHC.Int

Bits Integer 
Instance details

Defined in Data.Bits

Bits Natural 
Instance details

Defined in Data.Bits

Bits Word 
Instance details

Defined in Data.Bits

Bits Word8 
Instance details

Defined in GHC.Word

Bits Word16 
Instance details

Defined in GHC.Word

Bits Word32 
Instance details

Defined in GHC.Word

Bits Word64 
Instance details

Defined in GHC.Word

Bits CInt 
Instance details

Defined in Foreign.C.Types

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 CSize 
Instance details

Defined in Foreign.C.Types

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 CSsize 
Instance details

Defined in System.Posix.Types

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 CChar 
Instance details

Defined in Foreign.C.Types

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 CUChar 
Instance details

Defined in Foreign.C.Types

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 Word128 
Instance details

Defined in Basement.Types.Word128

Bits Word256 
Instance details

Defined in Basement.Types.Word256

Bits CIntMax 
Instance details

Defined in Foreign.C.Types

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 CLLong 
Instance details

Defined in Foreign.C.Types

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 CLong 
Instance details

Defined in Foreign.C.Types

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 CPtrdiff 
Instance details

Defined in Foreign.C.Types

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 CSChar 
Instance details

Defined in Foreign.C.Types

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 CShort 
Instance details

Defined in Foreign.C.Types

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 CWchar 
Instance details

Defined in Foreign.C.Types

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 CBool 
Instance details

Defined in Foreign.C.Types

Methods

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

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

xor :: CBool -> CBool -> CBool #

complement :: CBool -> CBool #

shift :: CBool -> Int -> CBool #

rotate :: CBool -> Int -> CBool #

zeroBits :: CBool #

bit :: Int -> CBool #

setBit :: CBool -> Int -> CBool #

clearBit :: CBool -> Int -> CBool #

complementBit :: CBool -> Int -> CBool #

testBit :: CBool -> Int -> Bool #

bitSizeMaybe :: CBool -> Maybe Int #

bitSize :: CBool -> Int #

isSigned :: CBool -> Bool #

shiftL :: CBool -> Int -> CBool #

unsafeShiftL :: CBool -> Int -> CBool #

shiftR :: CBool -> Int -> CBool #

unsafeShiftR :: CBool -> Int -> CBool #

rotateL :: CBool -> Int -> CBool #

rotateR :: CBool -> Int -> CBool #

popCount :: CBool -> Int #

Bits CIntPtr 
Instance details

Defined in Foreign.C.Types

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 COff 
Instance details

Defined in System.Posix.Types

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 CSigAtomic 
Instance details

Defined in Foreign.C.Types

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 CUInt 
Instance details

Defined in Foreign.C.Types

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 CUIntMax 
Instance details

Defined in Foreign.C.Types

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 CUIntPtr 
Instance details

Defined in Foreign.C.Types

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 CULLong 
Instance details

Defined in Foreign.C.Types

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 CULong 
Instance details

Defined in Foreign.C.Types

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 CUShort 
Instance details

Defined in Foreign.C.Types

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 IntPtr 
Instance details

Defined in Foreign.Ptr

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 CMode 
Instance details

Defined in System.Posix.Types

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 CDev 
Instance details

Defined in System.Posix.Types

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 
Instance details

Defined in System.Posix.Types

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 CBlkCnt 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CBlkCnt -> CBlkCnt -> CBlkCnt #

complement :: CBlkCnt -> CBlkCnt #

shift :: CBlkCnt -> Int -> CBlkCnt #

rotate :: CBlkCnt -> Int -> CBlkCnt #

zeroBits :: CBlkCnt #

bit :: Int -> CBlkCnt #

setBit :: CBlkCnt -> Int -> CBlkCnt #

clearBit :: CBlkCnt -> Int -> CBlkCnt #

complementBit :: CBlkCnt -> Int -> CBlkCnt #

testBit :: CBlkCnt -> Int -> Bool #

bitSizeMaybe :: CBlkCnt -> Maybe Int #

bitSize :: CBlkCnt -> Int #

isSigned :: CBlkCnt -> Bool #

shiftL :: CBlkCnt -> Int -> CBlkCnt #

unsafeShiftL :: CBlkCnt -> Int -> CBlkCnt #

shiftR :: CBlkCnt -> Int -> CBlkCnt #

unsafeShiftR :: CBlkCnt -> Int -> CBlkCnt #

rotateL :: CBlkCnt -> Int -> CBlkCnt #

rotateR :: CBlkCnt -> Int -> CBlkCnt #

popCount :: CBlkCnt -> Int #

Bits CBlkSize 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CBlkSize -> CBlkSize -> CBlkSize #

complement :: CBlkSize -> CBlkSize #

shift :: CBlkSize -> Int -> CBlkSize #

rotate :: CBlkSize -> Int -> CBlkSize #

zeroBits :: CBlkSize #

bit :: Int -> CBlkSize #

setBit :: CBlkSize -> Int -> CBlkSize #

clearBit :: CBlkSize -> Int -> CBlkSize #

complementBit :: CBlkSize -> Int -> CBlkSize #

testBit :: CBlkSize -> Int -> Bool #

bitSizeMaybe :: CBlkSize -> Maybe Int #

bitSize :: CBlkSize -> Int #

isSigned :: CBlkSize -> Bool #

shiftL :: CBlkSize -> Int -> CBlkSize #

unsafeShiftL :: CBlkSize -> Int -> CBlkSize #

shiftR :: CBlkSize -> Int -> CBlkSize #

unsafeShiftR :: CBlkSize -> Int -> CBlkSize #

rotateL :: CBlkSize -> Int -> CBlkSize #

rotateR :: CBlkSize -> Int -> CBlkSize #

popCount :: CBlkSize -> Int #

Bits CClockId 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CClockId -> CClockId -> CClockId #

complement :: CClockId -> CClockId #

shift :: CClockId -> Int -> CClockId #

rotate :: CClockId -> Int -> CClockId #

zeroBits :: CClockId #

bit :: Int -> CClockId #

setBit :: CClockId -> Int -> CClockId #

clearBit :: CClockId -> Int -> CClockId #

complementBit :: CClockId -> Int -> CClockId #

testBit :: CClockId -> Int -> Bool #

bitSizeMaybe :: CClockId -> Maybe Int #

bitSize :: CClockId -> Int #

isSigned :: CClockId -> Bool #

shiftL :: CClockId -> Int -> CClockId #

unsafeShiftL :: CClockId -> Int -> CClockId #

shiftR :: CClockId -> Int -> CClockId #

unsafeShiftR :: CClockId -> Int -> CClockId #

rotateL :: CClockId -> Int -> CClockId #

rotateR :: CClockId -> Int -> CClockId #

popCount :: CClockId -> Int #

Bits CFsBlkCnt 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt #

complement :: CFsBlkCnt -> CFsBlkCnt #

shift :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotate :: CFsBlkCnt -> Int -> CFsBlkCnt #

zeroBits :: CFsBlkCnt #

bit :: Int -> CFsBlkCnt #

setBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

clearBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

complementBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

testBit :: CFsBlkCnt -> Int -> Bool #

bitSizeMaybe :: CFsBlkCnt -> Maybe Int #

bitSize :: CFsBlkCnt -> Int #

isSigned :: CFsBlkCnt -> Bool #

shiftL :: CFsBlkCnt -> Int -> CFsBlkCnt #

unsafeShiftL :: CFsBlkCnt -> Int -> CFsBlkCnt #

shiftR :: CFsBlkCnt -> Int -> CFsBlkCnt #

unsafeShiftR :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotateL :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotateR :: CFsBlkCnt -> Int -> CFsBlkCnt #

popCount :: CFsBlkCnt -> Int #

Bits CFsFilCnt 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt #

complement :: CFsFilCnt -> CFsFilCnt #

shift :: CFsFilCnt -> Int -> CFsFilCnt #

rotate :: CFsFilCnt -> Int -> CFsFilCnt #

zeroBits :: CFsFilCnt #

bit :: Int -> CFsFilCnt #

setBit :: CFsFilCnt -> Int -> CFsFilCnt #

clearBit :: CFsFilCnt -> Int -> CFsFilCnt #

complementBit :: CFsFilCnt -> Int -> CFsFilCnt #

testBit :: CFsFilCnt -> Int -> Bool #

bitSizeMaybe :: CFsFilCnt -> Maybe Int #

bitSize :: CFsFilCnt -> Int #

isSigned :: CFsFilCnt -> Bool #

shiftL :: CFsFilCnt -> Int -> CFsFilCnt #

unsafeShiftL :: CFsFilCnt -> Int -> CFsFilCnt #

shiftR :: CFsFilCnt -> Int -> CFsFilCnt #

unsafeShiftR :: CFsFilCnt -> Int -> CFsFilCnt #

rotateL :: CFsFilCnt -> Int -> CFsFilCnt #

rotateR :: CFsFilCnt -> Int -> CFsFilCnt #

popCount :: CFsFilCnt -> Int #

Bits CGid 
Instance details

Defined in System.Posix.Types

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 CId 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CId -> CId -> CId #

complement :: CId -> CId #

shift :: CId -> Int -> CId #

rotate :: CId -> Int -> CId #

zeroBits :: CId #

bit :: Int -> CId #

setBit :: CId -> Int -> CId #

clearBit :: CId -> Int -> CId #

complementBit :: CId -> Int -> CId #

testBit :: CId -> Int -> Bool #

bitSizeMaybe :: CId -> Maybe Int #

bitSize :: CId -> Int #

isSigned :: CId -> Bool #

shiftL :: CId -> Int -> CId #

unsafeShiftL :: CId -> Int -> CId #

shiftR :: CId -> Int -> CId #

unsafeShiftR :: CId -> Int -> CId #

rotateL :: CId -> Int -> CId #

rotateR :: CId -> Int -> CId #

popCount :: CId -> Int #

Bits CKey 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CKey -> CKey -> CKey #

complement :: CKey -> CKey #

shift :: CKey -> Int -> CKey #

rotate :: CKey -> Int -> CKey #

zeroBits :: CKey #

bit :: Int -> CKey #

setBit :: CKey -> Int -> CKey #

clearBit :: CKey -> Int -> CKey #

complementBit :: CKey -> Int -> CKey #

testBit :: CKey -> Int -> Bool #

bitSizeMaybe :: CKey -> Maybe Int #

bitSize :: CKey -> Int #

isSigned :: CKey -> Bool #

shiftL :: CKey -> Int -> CKey #

unsafeShiftL :: CKey -> Int -> CKey #

shiftR :: CKey -> Int -> CKey #

unsafeShiftR :: CKey -> Int -> CKey #

rotateL :: CKey -> Int -> CKey #

rotateR :: CKey -> Int -> CKey #

popCount :: CKey -> Int #

Bits CNfds 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CNfds -> CNfds -> CNfds #

complement :: CNfds -> CNfds #

shift :: CNfds -> Int -> CNfds #

rotate :: CNfds -> Int -> CNfds #

zeroBits :: CNfds #

bit :: Int -> CNfds #

setBit :: CNfds -> Int -> CNfds #

clearBit :: CNfds -> Int -> CNfds #

complementBit :: CNfds -> Int -> CNfds #

testBit :: CNfds -> Int -> Bool #

bitSizeMaybe :: CNfds -> Maybe Int #

bitSize :: CNfds -> Int #

isSigned :: CNfds -> Bool #

shiftL :: CNfds -> Int -> CNfds #

unsafeShiftL :: CNfds -> Int -> CNfds #

shiftR :: CNfds -> Int -> CNfds #

unsafeShiftR :: CNfds -> Int -> CNfds #

rotateL :: CNfds -> Int -> CNfds #

rotateR :: CNfds -> Int -> CNfds #

popCount :: CNfds -> Int #

Bits CNlink 
Instance details

Defined in System.Posix.Types

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 CPid 
Instance details

Defined in System.Posix.Types

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 CRLim 
Instance details

Defined in System.Posix.Types

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 CSocklen 
Instance details

Defined in System.Posix.Types

Methods

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

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

xor :: CSocklen -> CSocklen -> CSocklen #

complement :: CSocklen -> CSocklen #

shift :: CSocklen -> Int -> CSocklen #

rotate :: CSocklen -> Int -> CSocklen #

zeroBits :: CSocklen #

bit :: Int -> CSocklen #

setBit :: CSocklen -> Int -> CSocklen #

clearBit :: CSocklen -> Int -> CSocklen #

complementBit :: CSocklen -> Int -> CSocklen #

testBit :: CSocklen -> Int -> Bool #

bitSizeMaybe :: CSocklen -> Maybe Int #

bitSize :: CSocklen -> Int #

isSigned :: CSocklen -> Bool #

shiftL :: CSocklen -> Int -> CSocklen #

unsafeShiftL :: CSocklen -> Int -> CSocklen #

shiftR :: CSocklen -> Int -> CSocklen #

unsafeShiftR :: CSocklen -> Int -> CSocklen #

rotateL :: CSocklen -> Int -> CSocklen #

rotateR :: CSocklen -> Int -> CSocklen #

popCount :: CSocklen -> Int #

Bits CTcflag 
Instance details

Defined in System.Posix.Types

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 CUid 
Instance details

Defined in System.Posix.Types

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 Fd 
Instance details

Defined in System.Posix.Types

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 
Instance details

Defined in Foreign.Ptr

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 a => Bits (BE a) 
Instance details

Defined in Basement.Endianness

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 (LE a) 
Instance details

Defined in Basement.Endianness

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 (Down a) 
Instance details

Defined in Data.Ord

Methods

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

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

xor :: Down a -> Down a -> Down a #

complement :: Down a -> Down a #

shift :: Down a -> Int -> Down a #

rotate :: Down a -> Int -> Down a #

zeroBits :: Down a #

bit :: Int -> Down a #

setBit :: Down a -> Int -> Down a #

clearBit :: Down a -> Int -> Down a #

complementBit :: Down a -> Int -> Down a #

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

bitSizeMaybe :: Down a -> Maybe Int #

bitSize :: Down a -> Int #

isSigned :: Down a -> Bool #

shiftL :: Down a -> Int -> Down a #

unsafeShiftL :: Down a -> Int -> Down a #

shiftR :: Down a -> Int -> Down a #

unsafeShiftR :: Down a -> Int -> Down a #

rotateL :: Down a -> Int -> Down a #

rotateR :: Down a -> Int -> Down a #

popCount :: Down a -> Int #

Bits a => Bits (Identity a) 
Instance details

Defined in Data.Functor.Identity

Bits a => Bits (Const a b) 
Instance details

Defined in Data.Functor.Const

Methods

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

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

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

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

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

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

zeroBits :: Const a b #

bit :: Int -> Const a b #

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

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

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

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

bitSizeMaybe :: Const a b -> Maybe Int #

bitSize :: Const a b -> Int #

isSigned :: Const a b -> Bool #

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

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

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

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

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

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

popCount :: Const 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