foundation-0.0.30: 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 CBool 
Instance details

Defined in Foreign.C.Types

Bits CChar 
Instance details

Defined in Foreign.C.Types

Bits CInt 
Instance details

Defined in Foreign.C.Types

Bits CIntMax 
Instance details

Defined in Foreign.C.Types

Bits CIntPtr 
Instance details

Defined in Foreign.C.Types

Bits CLLong 
Instance details

Defined in Foreign.C.Types

Bits CLong 
Instance details

Defined in Foreign.C.Types

Bits CPtrdiff 
Instance details

Defined in Foreign.C.Types

Bits CSChar 
Instance details

Defined in Foreign.C.Types

Bits CShort 
Instance details

Defined in Foreign.C.Types

Bits CSigAtomic 
Instance details

Defined in Foreign.C.Types

Bits CSize 
Instance details

Defined in Foreign.C.Types

Bits CUChar 
Instance details

Defined in Foreign.C.Types

Bits CUInt 
Instance details

Defined in Foreign.C.Types

Bits CUIntMax 
Instance details

Defined in Foreign.C.Types

Bits CUIntPtr 
Instance details

Defined in Foreign.C.Types

Bits CULLong 
Instance details

Defined in Foreign.C.Types

Bits CULong 
Instance details

Defined in Foreign.C.Types

Bits CUShort 
Instance details

Defined in Foreign.C.Types

Bits CWchar 
Instance details

Defined in Foreign.C.Types

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

Defined in GHC.Int

Bits Int32 
Instance details

Defined in GHC.Int

Bits Int64 
Instance details

Defined in GHC.Int

Bits Int8 
Instance details

Defined in GHC.Int

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

Defined in GHC.Word

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

Defined in System.Posix.Types

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

Defined in System.Posix.Types

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

Defined in Basement.Types.Word128

Bits Word256 
Instance details

Defined in Basement.Types.Word256

Bits Integer 
Instance details

Defined in GHC.Bits

Bits Natural 
Instance details

Defined in GHC.Bits

Bits Bool 
Instance details

Defined in GHC.Bits

Bits Int 
Instance details

Defined in GHC.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 Word 
Instance details

Defined in GHC.Bits

Bits a => Bits (And a) 
Instance details

Defined in Data.Bits

Methods

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

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

xor :: And a -> And a -> And a #

complement :: And a -> And a #

shift :: And a -> Int -> And a #

rotate :: And a -> Int -> And a #

zeroBits :: And a #

bit :: Int -> And a #

setBit :: And a -> Int -> And a #

clearBit :: And a -> Int -> And a #

complementBit :: And a -> Int -> And a #

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

bitSizeMaybe :: And a -> Maybe Int #

bitSize :: And a -> Int #

isSigned :: And a -> Bool #

shiftL :: And a -> Int -> And a #

unsafeShiftL :: And a -> Int -> And a #

shiftR :: And a -> Int -> And a #

unsafeShiftR :: And a -> Int -> And a #

rotateL :: And a -> Int -> And a #

rotateR :: And a -> Int -> And a #

popCount :: And a -> Int #

Bits a => Bits (Iff a) 
Instance details

Defined in Data.Bits

Methods

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

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

xor :: Iff a -> Iff a -> Iff a #

complement :: Iff a -> Iff a #

shift :: Iff a -> Int -> Iff a #

rotate :: Iff a -> Int -> Iff a #

zeroBits :: Iff a #

bit :: Int -> Iff a #

setBit :: Iff a -> Int -> Iff a #

clearBit :: Iff a -> Int -> Iff a #

complementBit :: Iff a -> Int -> Iff a #

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

bitSizeMaybe :: Iff a -> Maybe Int #

bitSize :: Iff a -> Int #

isSigned :: Iff a -> Bool #

shiftL :: Iff a -> Int -> Iff a #

unsafeShiftL :: Iff a -> Int -> Iff a #

shiftR :: Iff a -> Int -> Iff a #

unsafeShiftR :: Iff a -> Int -> Iff a #

rotateL :: Iff a -> Int -> Iff a #

rotateR :: Iff a -> Int -> Iff a #

popCount :: Iff a -> Int #

Bits a => Bits (Ior a) 
Instance details

Defined in Data.Bits

Methods

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

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

xor :: Ior a -> Ior a -> Ior a #

complement :: Ior a -> Ior a #

shift :: Ior a -> Int -> Ior a #

rotate :: Ior a -> Int -> Ior a #

zeroBits :: Ior a #

bit :: Int -> Ior a #

setBit :: Ior a -> Int -> Ior a #

clearBit :: Ior a -> Int -> Ior a #

complementBit :: Ior a -> Int -> Ior a #

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

bitSizeMaybe :: Ior a -> Maybe Int #

bitSize :: Ior a -> Int #

isSigned :: Ior a -> Bool #

shiftL :: Ior a -> Int -> Ior a #

unsafeShiftL :: Ior a -> Int -> Ior a #

shiftR :: Ior a -> Int -> Ior a #

unsafeShiftR :: Ior a -> Int -> Ior a #

rotateL :: Ior a -> Int -> Ior a #

rotateR :: Ior a -> Int -> Ior a #

popCount :: Ior a -> Int #

Bits a => Bits (Xor a) 
Instance details

Defined in Data.Bits

Methods

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

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

xor :: Xor a -> Xor a -> Xor a #

complement :: Xor a -> Xor a #

shift :: Xor a -> Int -> Xor a #

rotate :: Xor a -> Int -> Xor a #

zeroBits :: Xor a #

bit :: Int -> Xor a #

setBit :: Xor a -> Int -> Xor a #

clearBit :: Xor a -> Int -> Xor a #

complementBit :: Xor a -> Int -> Xor a #

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

bitSizeMaybe :: Xor a -> Maybe Int #

bitSize :: Xor a -> Int #

isSigned :: Xor a -> Bool #

shiftL :: Xor a -> Int -> Xor a #

unsafeShiftL :: Xor a -> Int -> Xor a #

shiftR :: Xor a -> Int -> Xor a #

unsafeShiftR :: Xor a -> Int -> Xor a #

rotateL :: Xor a -> Int -> Xor a #

rotateR :: Xor a -> Int -> Xor a #

popCount :: Xor a -> Int #

Bits a => Bits (Identity a) 
Instance details

Defined in Data.Functor.Identity

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 (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 (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