Safe Haskell	None
Language	Haskell2010

Data.ShortWord

Description

This module provides signed and unsigned binary word data types of sizes 2, 3, 4, 5, 6, 7, 24, and 48 bits.

Documentation

module Data.BinaryWord

data Word2 Source #

Instances

Bounded Word2 Source #
Methods minBound :: Word2 # maxBound :: Word2 #
Enum Word2 Source #
Methods succ :: Word2 -> Word2 # pred :: Word2 -> Word2 # toEnum :: Int -> Word2 # fromEnum :: Word2 -> Int # enumFrom :: Word2 -> [Word2] # enumFromThen :: Word2 -> Word2 -> [Word2] # enumFromTo :: Word2 -> Word2 -> [Word2] # enumFromThenTo :: Word2 -> Word2 -> Word2 -> [Word2] #
Eq Word2 Source #
Methods (==) :: Word2 -> Word2 -> Bool # (/=) :: Word2 -> Word2 -> Bool #
Integral Word2 Source #
Methods quot :: Word2 -> Word2 -> Word2 # rem :: Word2 -> Word2 -> Word2 # div :: Word2 -> Word2 -> Word2 # mod :: Word2 -> Word2 -> Word2 # quotRem :: Word2 -> Word2 -> (Word2, Word2) # divMod :: Word2 -> Word2 -> (Word2, Word2) # toInteger :: Word2 -> Integer #
Data Word2 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word2 -> c Word2 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word2 # toConstr :: Word2 -> Constr # dataTypeOf :: Word2 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word2) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word2) # gmapT :: (forall b. Data b => b -> b) -> Word2 -> Word2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word2 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 #
Num Word2 Source #
Methods (+) :: Word2 -> Word2 -> Word2 # (-) :: Word2 -> Word2 -> Word2 # (*) :: Word2 -> Word2 -> Word2 # negate :: Word2 -> Word2 # abs :: Word2 -> Word2 # signum :: Word2 -> Word2 # fromInteger :: Integer -> Word2 #
Ord Word2 Source #
Methods compare :: Word2 -> Word2 -> Ordering # (<) :: Word2 -> Word2 -> Bool # (<=) :: Word2 -> Word2 -> Bool # (>) :: Word2 -> Word2 -> Bool # (>=) :: Word2 -> Word2 -> Bool # max :: Word2 -> Word2 -> Word2 # min :: Word2 -> Word2 -> Word2 #
Read Word2 Source #
Methods readsPrec :: Int -> ReadS Word2 # readList :: ReadS [Word2] # readPrec :: ReadPrec Word2 # readListPrec :: ReadPrec [Word2] #
Real Word2 Source #
Methods toRational :: Word2 -> Rational #
Show Word2 Source #
Methods showsPrec :: Int -> Word2 -> ShowS # show :: Word2 -> String # showList :: [Word2] -> ShowS #
Ix Word2 Source #
Methods range :: (Word2, Word2) -> [Word2] # index :: (Word2, Word2) -> Word2 -> Int # unsafeIndex :: (Word2, Word2) -> Word2 -> Int inRange :: (Word2, Word2) -> Word2 -> Bool # rangeSize :: (Word2, Word2) -> Int # unsafeRangeSize :: (Word2, Word2) -> Int
Bits Word2 Source #
Methods (.&.) :: Word2 -> Word2 -> Word2 # (.\|.) :: Word2 -> Word2 -> Word2 # xor :: Word2 -> Word2 -> Word2 # complement :: Word2 -> Word2 # shift :: Word2 -> Int -> Word2 # rotate :: Word2 -> Int -> Word2 # zeroBits :: Word2 # bit :: Int -> Word2 # setBit :: Word2 -> Int -> Word2 # clearBit :: Word2 -> Int -> Word2 # complementBit :: Word2 -> Int -> Word2 # testBit :: Word2 -> Int -> Bool # bitSizeMaybe :: Word2 -> Maybe Int # bitSize :: Word2 -> Int # isSigned :: Word2 -> Bool # shiftL :: Word2 -> Int -> Word2 # unsafeShiftL :: Word2 -> Int -> Word2 # shiftR :: Word2 -> Int -> Word2 # unsafeShiftR :: Word2 -> Int -> Word2 # rotateL :: Word2 -> Int -> Word2 # rotateR :: Word2 -> Int -> Word2 # popCount :: Word2 -> Int #
FiniteBits Word2 Source #
Methods finiteBitSize :: Word2 -> Int # countLeadingZeros :: Word2 -> Int # countTrailingZeros :: Word2 -> Int #
BinaryWord Word2 Source #
Associated Types type UnsignedWord Word2 :: * # type SignedWord Word2 :: * # Methods unsignedWord :: Word2 -> UnsignedWord Word2 # signedWord :: Word2 -> SignedWord Word2 # unwrappedAdd :: Word2 -> Word2 -> (Word2, UnsignedWord Word2) # unwrappedMul :: Word2 -> Word2 -> (Word2, UnsignedWord Word2) # leadingZeroes :: Word2 -> Int # trailingZeroes :: Word2 -> Int # allZeroes :: Word2 # allOnes :: Word2 # msb :: Word2 # lsb :: Word2 # testMsb :: Word2 -> Bool # testLsb :: Word2 -> Bool # setMsb :: Word2 -> Word2 # setLsb :: Word2 -> Word2 # clearMsb :: Word2 -> Word2 # clearLsb :: Word2 -> Word2 #
Hashable Word2 Source #
Methods hashWithSalt :: Int -> Word2 -> Int # hash :: Word2 -> Int #
type SignedWord Word2 Source #
type SignedWord Word2 = Int2
type UnsignedWord Word2 Source #
type UnsignedWord Word2 = Word2

aWord2 :: Proxy Word2 Source #

data Word3 Source #

Instances

Bounded Word3 Source #
Methods minBound :: Word3 # maxBound :: Word3 #
Enum Word3 Source #
Methods succ :: Word3 -> Word3 # pred :: Word3 -> Word3 # toEnum :: Int -> Word3 # fromEnum :: Word3 -> Int # enumFrom :: Word3 -> [Word3] # enumFromThen :: Word3 -> Word3 -> [Word3] # enumFromTo :: Word3 -> Word3 -> [Word3] # enumFromThenTo :: Word3 -> Word3 -> Word3 -> [Word3] #
Eq Word3 Source #
Methods (==) :: Word3 -> Word3 -> Bool # (/=) :: Word3 -> Word3 -> Bool #
Integral Word3 Source #
Methods quot :: Word3 -> Word3 -> Word3 # rem :: Word3 -> Word3 -> Word3 # div :: Word3 -> Word3 -> Word3 # mod :: Word3 -> Word3 -> Word3 # quotRem :: Word3 -> Word3 -> (Word3, Word3) # divMod :: Word3 -> Word3 -> (Word3, Word3) # toInteger :: Word3 -> Integer #
Data Word3 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word3 -> c Word3 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word3 # toConstr :: Word3 -> Constr # dataTypeOf :: Word3 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word3) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word3) # gmapT :: (forall b. Data b => b -> b) -> Word3 -> Word3 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word3 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word3 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word3 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word3 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word3 -> m Word3 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word3 -> m Word3 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word3 -> m Word3 #
Num Word3 Source #
Methods (+) :: Word3 -> Word3 -> Word3 # (-) :: Word3 -> Word3 -> Word3 # (*) :: Word3 -> Word3 -> Word3 # negate :: Word3 -> Word3 # abs :: Word3 -> Word3 # signum :: Word3 -> Word3 # fromInteger :: Integer -> Word3 #
Ord Word3 Source #
Methods compare :: Word3 -> Word3 -> Ordering # (<) :: Word3 -> Word3 -> Bool # (<=) :: Word3 -> Word3 -> Bool # (>) :: Word3 -> Word3 -> Bool # (>=) :: Word3 -> Word3 -> Bool # max :: Word3 -> Word3 -> Word3 # min :: Word3 -> Word3 -> Word3 #
Read Word3 Source #
Methods readsPrec :: Int -> ReadS Word3 # readList :: ReadS [Word3] # readPrec :: ReadPrec Word3 # readListPrec :: ReadPrec [Word3] #
Real Word3 Source #
Methods toRational :: Word3 -> Rational #
Show Word3 Source #
Methods showsPrec :: Int -> Word3 -> ShowS # show :: Word3 -> String # showList :: [Word3] -> ShowS #
Ix Word3 Source #
Methods range :: (Word3, Word3) -> [Word3] # index :: (Word3, Word3) -> Word3 -> Int # unsafeIndex :: (Word3, Word3) -> Word3 -> Int inRange :: (Word3, Word3) -> Word3 -> Bool # rangeSize :: (Word3, Word3) -> Int # unsafeRangeSize :: (Word3, Word3) -> Int
Bits Word3 Source #
Methods (.&.) :: Word3 -> Word3 -> Word3 # (.\|.) :: Word3 -> Word3 -> Word3 # xor :: Word3 -> Word3 -> Word3 # complement :: Word3 -> Word3 # shift :: Word3 -> Int -> Word3 # rotate :: Word3 -> Int -> Word3 # zeroBits :: Word3 # bit :: Int -> Word3 # setBit :: Word3 -> Int -> Word3 # clearBit :: Word3 -> Int -> Word3 # complementBit :: Word3 -> Int -> Word3 # testBit :: Word3 -> Int -> Bool # bitSizeMaybe :: Word3 -> Maybe Int # bitSize :: Word3 -> Int # isSigned :: Word3 -> Bool # shiftL :: Word3 -> Int -> Word3 # unsafeShiftL :: Word3 -> Int -> Word3 # shiftR :: Word3 -> Int -> Word3 # unsafeShiftR :: Word3 -> Int -> Word3 # rotateL :: Word3 -> Int -> Word3 # rotateR :: Word3 -> Int -> Word3 # popCount :: Word3 -> Int #
FiniteBits Word3 Source #
Methods finiteBitSize :: Word3 -> Int # countLeadingZeros :: Word3 -> Int # countTrailingZeros :: Word3 -> Int #
BinaryWord Word3 Source #
Associated Types type UnsignedWord Word3 :: * # type SignedWord Word3 :: * # Methods unsignedWord :: Word3 -> UnsignedWord Word3 # signedWord :: Word3 -> SignedWord Word3 # unwrappedAdd :: Word3 -> Word3 -> (Word3, UnsignedWord Word3) # unwrappedMul :: Word3 -> Word3 -> (Word3, UnsignedWord Word3) # leadingZeroes :: Word3 -> Int # trailingZeroes :: Word3 -> Int # allZeroes :: Word3 # allOnes :: Word3 # msb :: Word3 # lsb :: Word3 # testMsb :: Word3 -> Bool # testLsb :: Word3 -> Bool # setMsb :: Word3 -> Word3 # setLsb :: Word3 -> Word3 # clearMsb :: Word3 -> Word3 # clearLsb :: Word3 -> Word3 #
Hashable Word3 Source #
Methods hashWithSalt :: Int -> Word3 -> Int # hash :: Word3 -> Int #
type SignedWord Word3 Source #
type SignedWord Word3 = Int3
type UnsignedWord Word3 Source #
type UnsignedWord Word3 = Word3

aWord3 :: Proxy Word3 Source #

data Word4 Source #

Instances

Bounded Word4 Source #
Methods minBound :: Word4 # maxBound :: Word4 #
Enum Word4 Source #
Methods succ :: Word4 -> Word4 # pred :: Word4 -> Word4 # toEnum :: Int -> Word4 # fromEnum :: Word4 -> Int # enumFrom :: Word4 -> [Word4] # enumFromThen :: Word4 -> Word4 -> [Word4] # enumFromTo :: Word4 -> Word4 -> [Word4] # enumFromThenTo :: Word4 -> Word4 -> Word4 -> [Word4] #
Eq Word4 Source #
Methods (==) :: Word4 -> Word4 -> Bool # (/=) :: Word4 -> Word4 -> Bool #
Integral Word4 Source #
Methods quot :: Word4 -> Word4 -> Word4 # rem :: Word4 -> Word4 -> Word4 # div :: Word4 -> Word4 -> Word4 # mod :: Word4 -> Word4 -> Word4 # quotRem :: Word4 -> Word4 -> (Word4, Word4) # divMod :: Word4 -> Word4 -> (Word4, Word4) # toInteger :: Word4 -> Integer #
Data Word4 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word4 -> c Word4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word4 # toConstr :: Word4 -> Constr # dataTypeOf :: Word4 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word4) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word4) # gmapT :: (forall b. Data b => b -> b) -> Word4 -> Word4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word4 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 #
Num Word4 Source #
Methods (+) :: Word4 -> Word4 -> Word4 # (-) :: Word4 -> Word4 -> Word4 # (*) :: Word4 -> Word4 -> Word4 # negate :: Word4 -> Word4 # abs :: Word4 -> Word4 # signum :: Word4 -> Word4 # fromInteger :: Integer -> Word4 #
Ord Word4 Source #
Methods compare :: Word4 -> Word4 -> Ordering # (<) :: Word4 -> Word4 -> Bool # (<=) :: Word4 -> Word4 -> Bool # (>) :: Word4 -> Word4 -> Bool # (>=) :: Word4 -> Word4 -> Bool # max :: Word4 -> Word4 -> Word4 # min :: Word4 -> Word4 -> Word4 #
Read Word4 Source #
Methods readsPrec :: Int -> ReadS Word4 # readList :: ReadS [Word4] # readPrec :: ReadPrec Word4 # readListPrec :: ReadPrec [Word4] #
Real Word4 Source #
Methods toRational :: Word4 -> Rational #
Show Word4 Source #
Methods showsPrec :: Int -> Word4 -> ShowS # show :: Word4 -> String # showList :: [Word4] -> ShowS #
Ix Word4 Source #
Methods range :: (Word4, Word4) -> [Word4] # index :: (Word4, Word4) -> Word4 -> Int # unsafeIndex :: (Word4, Word4) -> Word4 -> Int inRange :: (Word4, Word4) -> Word4 -> Bool # rangeSize :: (Word4, Word4) -> Int # unsafeRangeSize :: (Word4, Word4) -> Int
Bits Word4 Source #
Methods (.&.) :: Word4 -> Word4 -> Word4 # (.\|.) :: Word4 -> Word4 -> Word4 # xor :: Word4 -> Word4 -> Word4 # complement :: Word4 -> Word4 # shift :: Word4 -> Int -> Word4 # rotate :: Word4 -> Int -> Word4 # zeroBits :: Word4 # bit :: Int -> Word4 # setBit :: Word4 -> Int -> Word4 # clearBit :: Word4 -> Int -> Word4 # complementBit :: Word4 -> Int -> Word4 # testBit :: Word4 -> Int -> Bool # bitSizeMaybe :: Word4 -> Maybe Int # bitSize :: Word4 -> Int # isSigned :: Word4 -> Bool # shiftL :: Word4 -> Int -> Word4 # unsafeShiftL :: Word4 -> Int -> Word4 # shiftR :: Word4 -> Int -> Word4 # unsafeShiftR :: Word4 -> Int -> Word4 # rotateL :: Word4 -> Int -> Word4 # rotateR :: Word4 -> Int -> Word4 # popCount :: Word4 -> Int #
FiniteBits Word4 Source #
Methods finiteBitSize :: Word4 -> Int # countLeadingZeros :: Word4 -> Int # countTrailingZeros :: Word4 -> Int #
BinaryWord Word4 Source #
Associated Types type UnsignedWord Word4 :: * # type SignedWord Word4 :: * # Methods unsignedWord :: Word4 -> UnsignedWord Word4 # signedWord :: Word4 -> SignedWord Word4 # unwrappedAdd :: Word4 -> Word4 -> (Word4, UnsignedWord Word4) # unwrappedMul :: Word4 -> Word4 -> (Word4, UnsignedWord Word4) # leadingZeroes :: Word4 -> Int # trailingZeroes :: Word4 -> Int # allZeroes :: Word4 # allOnes :: Word4 # msb :: Word4 # lsb :: Word4 # testMsb :: Word4 -> Bool # testLsb :: Word4 -> Bool # setMsb :: Word4 -> Word4 # setLsb :: Word4 -> Word4 # clearMsb :: Word4 -> Word4 # clearLsb :: Word4 -> Word4 #
Hashable Word4 Source #
Methods hashWithSalt :: Int -> Word4 -> Int # hash :: Word4 -> Int #
type SignedWord Word4 Source #
type SignedWord Word4 = Int4
type UnsignedWord Word4 Source #
type UnsignedWord Word4 = Word4

aWord4 :: Proxy Word4 Source #

data Word5 Source #

Instances

Bounded Word5 Source #
Methods minBound :: Word5 # maxBound :: Word5 #
Enum Word5 Source #
Methods succ :: Word5 -> Word5 # pred :: Word5 -> Word5 # toEnum :: Int -> Word5 # fromEnum :: Word5 -> Int # enumFrom :: Word5 -> [Word5] # enumFromThen :: Word5 -> Word5 -> [Word5] # enumFromTo :: Word5 -> Word5 -> [Word5] # enumFromThenTo :: Word5 -> Word5 -> Word5 -> [Word5] #
Eq Word5 Source #
Methods (==) :: Word5 -> Word5 -> Bool # (/=) :: Word5 -> Word5 -> Bool #
Integral Word5 Source #
Methods quot :: Word5 -> Word5 -> Word5 # rem :: Word5 -> Word5 -> Word5 # div :: Word5 -> Word5 -> Word5 # mod :: Word5 -> Word5 -> Word5 # quotRem :: Word5 -> Word5 -> (Word5, Word5) # divMod :: Word5 -> Word5 -> (Word5, Word5) # toInteger :: Word5 -> Integer #
Data Word5 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word5 -> c Word5 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word5 # toConstr :: Word5 -> Constr # dataTypeOf :: Word5 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word5) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word5) # gmapT :: (forall b. Data b => b -> b) -> Word5 -> Word5 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word5 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word5 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word5 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word5 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word5 -> m Word5 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word5 -> m Word5 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word5 -> m Word5 #
Num Word5 Source #
Methods (+) :: Word5 -> Word5 -> Word5 # (-) :: Word5 -> Word5 -> Word5 # (*) :: Word5 -> Word5 -> Word5 # negate :: Word5 -> Word5 # abs :: Word5 -> Word5 # signum :: Word5 -> Word5 # fromInteger :: Integer -> Word5 #
Ord Word5 Source #
Methods compare :: Word5 -> Word5 -> Ordering # (<) :: Word5 -> Word5 -> Bool # (<=) :: Word5 -> Word5 -> Bool # (>) :: Word5 -> Word5 -> Bool # (>=) :: Word5 -> Word5 -> Bool # max :: Word5 -> Word5 -> Word5 # min :: Word5 -> Word5 -> Word5 #
Read Word5 Source #
Methods readsPrec :: Int -> ReadS Word5 # readList :: ReadS [Word5] # readPrec :: ReadPrec Word5 # readListPrec :: ReadPrec [Word5] #
Real Word5 Source #
Methods toRational :: Word5 -> Rational #
Show Word5 Source #
Methods showsPrec :: Int -> Word5 -> ShowS # show :: Word5 -> String # showList :: [Word5] -> ShowS #
Ix Word5 Source #
Methods range :: (Word5, Word5) -> [Word5] # index :: (Word5, Word5) -> Word5 -> Int # unsafeIndex :: (Word5, Word5) -> Word5 -> Int inRange :: (Word5, Word5) -> Word5 -> Bool # rangeSize :: (Word5, Word5) -> Int # unsafeRangeSize :: (Word5, Word5) -> Int
Bits Word5 Source #
Methods (.&.) :: Word5 -> Word5 -> Word5 # (.\|.) :: Word5 -> Word5 -> Word5 # xor :: Word5 -> Word5 -> Word5 # complement :: Word5 -> Word5 # shift :: Word5 -> Int -> Word5 # rotate :: Word5 -> Int -> Word5 # zeroBits :: Word5 # bit :: Int -> Word5 # setBit :: Word5 -> Int -> Word5 # clearBit :: Word5 -> Int -> Word5 # complementBit :: Word5 -> Int -> Word5 # testBit :: Word5 -> Int -> Bool # bitSizeMaybe :: Word5 -> Maybe Int # bitSize :: Word5 -> Int # isSigned :: Word5 -> Bool # shiftL :: Word5 -> Int -> Word5 # unsafeShiftL :: Word5 -> Int -> Word5 # shiftR :: Word5 -> Int -> Word5 # unsafeShiftR :: Word5 -> Int -> Word5 # rotateL :: Word5 -> Int -> Word5 # rotateR :: Word5 -> Int -> Word5 # popCount :: Word5 -> Int #
FiniteBits Word5 Source #
Methods finiteBitSize :: Word5 -> Int # countLeadingZeros :: Word5 -> Int # countTrailingZeros :: Word5 -> Int #
BinaryWord Word5 Source #
Associated Types type UnsignedWord Word5 :: * # type SignedWord Word5 :: * # Methods unsignedWord :: Word5 -> UnsignedWord Word5 # signedWord :: Word5 -> SignedWord Word5 # unwrappedAdd :: Word5 -> Word5 -> (Word5, UnsignedWord Word5) # unwrappedMul :: Word5 -> Word5 -> (Word5, UnsignedWord Word5) # leadingZeroes :: Word5 -> Int # trailingZeroes :: Word5 -> Int # allZeroes :: Word5 # allOnes :: Word5 # msb :: Word5 # lsb :: Word5 # testMsb :: Word5 -> Bool # testLsb :: Word5 -> Bool # setMsb :: Word5 -> Word5 # setLsb :: Word5 -> Word5 # clearMsb :: Word5 -> Word5 # clearLsb :: Word5 -> Word5 #
Hashable Word5 Source #
Methods hashWithSalt :: Int -> Word5 -> Int # hash :: Word5 -> Int #
type SignedWord Word5 Source #
type SignedWord Word5 = Int5
type UnsignedWord Word5 Source #
type UnsignedWord Word5 = Word5

aWord5 :: Proxy Word5 Source #

data Word6 Source #

Instances

Bounded Word6 Source #
Methods minBound :: Word6 # maxBound :: Word6 #
Enum Word6 Source #
Methods succ :: Word6 -> Word6 # pred :: Word6 -> Word6 # toEnum :: Int -> Word6 # fromEnum :: Word6 -> Int # enumFrom :: Word6 -> [Word6] # enumFromThen :: Word6 -> Word6 -> [Word6] # enumFromTo :: Word6 -> Word6 -> [Word6] # enumFromThenTo :: Word6 -> Word6 -> Word6 -> [Word6] #
Eq Word6 Source #
Methods (==) :: Word6 -> Word6 -> Bool # (/=) :: Word6 -> Word6 -> Bool #
Integral Word6 Source #
Methods quot :: Word6 -> Word6 -> Word6 # rem :: Word6 -> Word6 -> Word6 # div :: Word6 -> Word6 -> Word6 # mod :: Word6 -> Word6 -> Word6 # quotRem :: Word6 -> Word6 -> (Word6, Word6) # divMod :: Word6 -> Word6 -> (Word6, Word6) # toInteger :: Word6 -> Integer #
Data Word6 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word6 -> c Word6 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word6 # toConstr :: Word6 -> Constr # dataTypeOf :: Word6 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word6) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word6) # gmapT :: (forall b. Data b => b -> b) -> Word6 -> Word6 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word6 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word6 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word6 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word6 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word6 -> m Word6 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word6 -> m Word6 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word6 -> m Word6 #
Num Word6 Source #
Methods (+) :: Word6 -> Word6 -> Word6 # (-) :: Word6 -> Word6 -> Word6 # (*) :: Word6 -> Word6 -> Word6 # negate :: Word6 -> Word6 # abs :: Word6 -> Word6 # signum :: Word6 -> Word6 # fromInteger :: Integer -> Word6 #
Ord Word6 Source #
Methods compare :: Word6 -> Word6 -> Ordering # (<) :: Word6 -> Word6 -> Bool # (<=) :: Word6 -> Word6 -> Bool # (>) :: Word6 -> Word6 -> Bool # (>=) :: Word6 -> Word6 -> Bool # max :: Word6 -> Word6 -> Word6 # min :: Word6 -> Word6 -> Word6 #
Read Word6 Source #
Methods readsPrec :: Int -> ReadS Word6 # readList :: ReadS [Word6] # readPrec :: ReadPrec Word6 # readListPrec :: ReadPrec [Word6] #
Real Word6 Source #
Methods toRational :: Word6 -> Rational #
Show Word6 Source #
Methods showsPrec :: Int -> Word6 -> ShowS # show :: Word6 -> String # showList :: [Word6] -> ShowS #
Ix Word6 Source #
Methods range :: (Word6, Word6) -> [Word6] # index :: (Word6, Word6) -> Word6 -> Int # unsafeIndex :: (Word6, Word6) -> Word6 -> Int inRange :: (Word6, Word6) -> Word6 -> Bool # rangeSize :: (Word6, Word6) -> Int # unsafeRangeSize :: (Word6, Word6) -> Int
Bits Word6 Source #
Methods (.&.) :: Word6 -> Word6 -> Word6 # (.\|.) :: Word6 -> Word6 -> Word6 # xor :: Word6 -> Word6 -> Word6 # complement :: Word6 -> Word6 # shift :: Word6 -> Int -> Word6 # rotate :: Word6 -> Int -> Word6 # zeroBits :: Word6 # bit :: Int -> Word6 # setBit :: Word6 -> Int -> Word6 # clearBit :: Word6 -> Int -> Word6 # complementBit :: Word6 -> Int -> Word6 # testBit :: Word6 -> Int -> Bool # bitSizeMaybe :: Word6 -> Maybe Int # bitSize :: Word6 -> Int # isSigned :: Word6 -> Bool # shiftL :: Word6 -> Int -> Word6 # unsafeShiftL :: Word6 -> Int -> Word6 # shiftR :: Word6 -> Int -> Word6 # unsafeShiftR :: Word6 -> Int -> Word6 # rotateL :: Word6 -> Int -> Word6 # rotateR :: Word6 -> Int -> Word6 # popCount :: Word6 -> Int #
FiniteBits Word6 Source #
Methods finiteBitSize :: Word6 -> Int # countLeadingZeros :: Word6 -> Int # countTrailingZeros :: Word6 -> Int #
BinaryWord Word6 Source #
Associated Types type UnsignedWord Word6 :: * # type SignedWord Word6 :: * # Methods unsignedWord :: Word6 -> UnsignedWord Word6 # signedWord :: Word6 -> SignedWord Word6 # unwrappedAdd :: Word6 -> Word6 -> (Word6, UnsignedWord Word6) # unwrappedMul :: Word6 -> Word6 -> (Word6, UnsignedWord Word6) # leadingZeroes :: Word6 -> Int # trailingZeroes :: Word6 -> Int # allZeroes :: Word6 # allOnes :: Word6 # msb :: Word6 # lsb :: Word6 # testMsb :: Word6 -> Bool # testLsb :: Word6 -> Bool # setMsb :: Word6 -> Word6 # setLsb :: Word6 -> Word6 # clearMsb :: Word6 -> Word6 # clearLsb :: Word6 -> Word6 #
Hashable Word6 Source #
Methods hashWithSalt :: Int -> Word6 -> Int # hash :: Word6 -> Int #
type SignedWord Word6 Source #
type SignedWord Word6 = Int6
type UnsignedWord Word6 Source #
type UnsignedWord Word6 = Word6

aWord6 :: Proxy Word6 Source #

data Word7 Source #

Instances

Bounded Word7 Source #
Methods minBound :: Word7 # maxBound :: Word7 #
Enum Word7 Source #
Methods succ :: Word7 -> Word7 # pred :: Word7 -> Word7 # toEnum :: Int -> Word7 # fromEnum :: Word7 -> Int # enumFrom :: Word7 -> [Word7] # enumFromThen :: Word7 -> Word7 -> [Word7] # enumFromTo :: Word7 -> Word7 -> [Word7] # enumFromThenTo :: Word7 -> Word7 -> Word7 -> [Word7] #
Eq Word7 Source #
Methods (==) :: Word7 -> Word7 -> Bool # (/=) :: Word7 -> Word7 -> Bool #
Integral Word7 Source #
Methods quot :: Word7 -> Word7 -> Word7 # rem :: Word7 -> Word7 -> Word7 # div :: Word7 -> Word7 -> Word7 # mod :: Word7 -> Word7 -> Word7 # quotRem :: Word7 -> Word7 -> (Word7, Word7) # divMod :: Word7 -> Word7 -> (Word7, Word7) # toInteger :: Word7 -> Integer #
Data Word7 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word7 -> c Word7 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word7 # toConstr :: Word7 -> Constr # dataTypeOf :: Word7 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word7) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word7) # gmapT :: (forall b. Data b => b -> b) -> Word7 -> Word7 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word7 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word7 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word7 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word7 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 #
Num Word7 Source #
Methods (+) :: Word7 -> Word7 -> Word7 # (-) :: Word7 -> Word7 -> Word7 # (*) :: Word7 -> Word7 -> Word7 # negate :: Word7 -> Word7 # abs :: Word7 -> Word7 # signum :: Word7 -> Word7 # fromInteger :: Integer -> Word7 #
Ord Word7 Source #
Methods compare :: Word7 -> Word7 -> Ordering # (<) :: Word7 -> Word7 -> Bool # (<=) :: Word7 -> Word7 -> Bool # (>) :: Word7 -> Word7 -> Bool # (>=) :: Word7 -> Word7 -> Bool # max :: Word7 -> Word7 -> Word7 # min :: Word7 -> Word7 -> Word7 #
Read Word7 Source #
Methods readsPrec :: Int -> ReadS Word7 # readList :: ReadS [Word7] # readPrec :: ReadPrec Word7 # readListPrec :: ReadPrec [Word7] #
Real Word7 Source #
Methods toRational :: Word7 -> Rational #
Show Word7 Source #
Methods showsPrec :: Int -> Word7 -> ShowS # show :: Word7 -> String # showList :: [Word7] -> ShowS #
Ix Word7 Source #
Methods range :: (Word7, Word7) -> [Word7] # index :: (Word7, Word7) -> Word7 -> Int # unsafeIndex :: (Word7, Word7) -> Word7 -> Int inRange :: (Word7, Word7) -> Word7 -> Bool # rangeSize :: (Word7, Word7) -> Int # unsafeRangeSize :: (Word7, Word7) -> Int
Bits Word7 Source #
Methods (.&.) :: Word7 -> Word7 -> Word7 # (.\|.) :: Word7 -> Word7 -> Word7 # xor :: Word7 -> Word7 -> Word7 # complement :: Word7 -> Word7 # shift :: Word7 -> Int -> Word7 # rotate :: Word7 -> Int -> Word7 # zeroBits :: Word7 # bit :: Int -> Word7 # setBit :: Word7 -> Int -> Word7 # clearBit :: Word7 -> Int -> Word7 # complementBit :: Word7 -> Int -> Word7 # testBit :: Word7 -> Int -> Bool # bitSizeMaybe :: Word7 -> Maybe Int # bitSize :: Word7 -> Int # isSigned :: Word7 -> Bool # shiftL :: Word7 -> Int -> Word7 # unsafeShiftL :: Word7 -> Int -> Word7 # shiftR :: Word7 -> Int -> Word7 # unsafeShiftR :: Word7 -> Int -> Word7 # rotateL :: Word7 -> Int -> Word7 # rotateR :: Word7 -> Int -> Word7 # popCount :: Word7 -> Int #
FiniteBits Word7 Source #
Methods finiteBitSize :: Word7 -> Int # countLeadingZeros :: Word7 -> Int # countTrailingZeros :: Word7 -> Int #
BinaryWord Word7 Source #
Associated Types type UnsignedWord Word7 :: * # type SignedWord Word7 :: * # Methods unsignedWord :: Word7 -> UnsignedWord Word7 # signedWord :: Word7 -> SignedWord Word7 # unwrappedAdd :: Word7 -> Word7 -> (Word7, UnsignedWord Word7) # unwrappedMul :: Word7 -> Word7 -> (Word7, UnsignedWord Word7) # leadingZeroes :: Word7 -> Int # trailingZeroes :: Word7 -> Int # allZeroes :: Word7 # allOnes :: Word7 # msb :: Word7 # lsb :: Word7 # testMsb :: Word7 -> Bool # testLsb :: Word7 -> Bool # setMsb :: Word7 -> Word7 # setLsb :: Word7 -> Word7 # clearMsb :: Word7 -> Word7 # clearLsb :: Word7 -> Word7 #
Hashable Word7 Source #
Methods hashWithSalt :: Int -> Word7 -> Int # hash :: Word7 -> Int #
type SignedWord Word7 Source #
type SignedWord Word7 = Int7
type UnsignedWord Word7 Source #
type UnsignedWord Word7 = Word7

aWord7 :: Proxy Word7 Source #

data Word24 Source #

Instances

Bounded Word24 Source #
Methods minBound :: Word24 # maxBound :: Word24 #
Enum Word24 Source #
Methods succ :: Word24 -> Word24 # pred :: Word24 -> Word24 # toEnum :: Int -> Word24 # fromEnum :: Word24 -> Int # enumFrom :: Word24 -> [Word24] # enumFromThen :: Word24 -> Word24 -> [Word24] # enumFromTo :: Word24 -> Word24 -> [Word24] # enumFromThenTo :: Word24 -> Word24 -> Word24 -> [Word24] #
Eq Word24 Source #
Methods (==) :: Word24 -> Word24 -> Bool # (/=) :: Word24 -> Word24 -> Bool #
Integral Word24 Source #
Methods quot :: Word24 -> Word24 -> Word24 # rem :: Word24 -> Word24 -> Word24 # div :: Word24 -> Word24 -> Word24 # mod :: Word24 -> Word24 -> Word24 # quotRem :: Word24 -> Word24 -> (Word24, Word24) # divMod :: Word24 -> Word24 -> (Word24, Word24) # toInteger :: Word24 -> Integer #
Data Word24 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word24 -> c Word24 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word24 # toConstr :: Word24 -> Constr # dataTypeOf :: Word24 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word24) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word24) # gmapT :: (forall b. Data b => b -> b) -> Word24 -> Word24 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word24 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word24 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word24 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word24 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 #
Num Word24 Source #
Methods (+) :: Word24 -> Word24 -> Word24 # (-) :: Word24 -> Word24 -> Word24 # (*) :: Word24 -> Word24 -> Word24 # negate :: Word24 -> Word24 # abs :: Word24 -> Word24 # signum :: Word24 -> Word24 # fromInteger :: Integer -> Word24 #
Ord Word24 Source #
Methods compare :: Word24 -> Word24 -> Ordering # (<) :: Word24 -> Word24 -> Bool # (<=) :: Word24 -> Word24 -> Bool # (>) :: Word24 -> Word24 -> Bool # (>=) :: Word24 -> Word24 -> Bool # max :: Word24 -> Word24 -> Word24 # min :: Word24 -> Word24 -> Word24 #
Read Word24 Source #
Methods readsPrec :: Int -> ReadS Word24 # readList :: ReadS [Word24] # readPrec :: ReadPrec Word24 # readListPrec :: ReadPrec [Word24] #
Real Word24 Source #
Methods toRational :: Word24 -> Rational #
Show Word24 Source #
Methods showsPrec :: Int -> Word24 -> ShowS # show :: Word24 -> String # showList :: [Word24] -> ShowS #
Ix Word24 Source #
Methods range :: (Word24, Word24) -> [Word24] # index :: (Word24, Word24) -> Word24 -> Int # unsafeIndex :: (Word24, Word24) -> Word24 -> Int inRange :: (Word24, Word24) -> Word24 -> Bool # rangeSize :: (Word24, Word24) -> Int # unsafeRangeSize :: (Word24, Word24) -> Int
Bits Word24 Source #
Methods (.&.) :: Word24 -> Word24 -> Word24 # (.\|.) :: Word24 -> Word24 -> Word24 # xor :: Word24 -> Word24 -> Word24 # complement :: Word24 -> Word24 # shift :: Word24 -> Int -> Word24 # rotate :: Word24 -> Int -> Word24 # zeroBits :: Word24 # bit :: Int -> Word24 # setBit :: Word24 -> Int -> Word24 # clearBit :: Word24 -> Int -> Word24 # complementBit :: Word24 -> Int -> Word24 # testBit :: Word24 -> Int -> Bool # bitSizeMaybe :: Word24 -> Maybe Int # bitSize :: Word24 -> Int # isSigned :: Word24 -> Bool # shiftL :: Word24 -> Int -> Word24 # unsafeShiftL :: Word24 -> Int -> Word24 # shiftR :: Word24 -> Int -> Word24 # unsafeShiftR :: Word24 -> Int -> Word24 # rotateL :: Word24 -> Int -> Word24 # rotateR :: Word24 -> Int -> Word24 # popCount :: Word24 -> Int #
FiniteBits Word24 Source #
Methods finiteBitSize :: Word24 -> Int # countLeadingZeros :: Word24 -> Int # countTrailingZeros :: Word24 -> Int #
BinaryWord Word24 Source #
Associated Types type UnsignedWord Word24 :: * # type SignedWord Word24 :: * # Methods unsignedWord :: Word24 -> UnsignedWord Word24 # signedWord :: Word24 -> SignedWord Word24 # unwrappedAdd :: Word24 -> Word24 -> (Word24, UnsignedWord Word24) # unwrappedMul :: Word24 -> Word24 -> (Word24, UnsignedWord Word24) # leadingZeroes :: Word24 -> Int # trailingZeroes :: Word24 -> Int # allZeroes :: Word24 # allOnes :: Word24 # msb :: Word24 # lsb :: Word24 # testMsb :: Word24 -> Bool # testLsb :: Word24 -> Bool # setMsb :: Word24 -> Word24 # setLsb :: Word24 -> Word24 # clearMsb :: Word24 -> Word24 # clearLsb :: Word24 -> Word24 #
Hashable Word24 Source #
Methods hashWithSalt :: Int -> Word24 -> Int # hash :: Word24 -> Int #
type SignedWord Word24 Source #
type SignedWord Word24 = Int24
type UnsignedWord Word24 Source #
type UnsignedWord Word24 = Word24

aWord24 :: Proxy Word24 Source #

data Word48 Source #

Instances

Bounded Word48 Source #
Methods minBound :: Word48 # maxBound :: Word48 #
Enum Word48 Source #
Methods succ :: Word48 -> Word48 # pred :: Word48 -> Word48 # toEnum :: Int -> Word48 # fromEnum :: Word48 -> Int # enumFrom :: Word48 -> [Word48] # enumFromThen :: Word48 -> Word48 -> [Word48] # enumFromTo :: Word48 -> Word48 -> [Word48] # enumFromThenTo :: Word48 -> Word48 -> Word48 -> [Word48] #
Eq Word48 Source #
Methods (==) :: Word48 -> Word48 -> Bool # (/=) :: Word48 -> Word48 -> Bool #
Integral Word48 Source #
Methods quot :: Word48 -> Word48 -> Word48 # rem :: Word48 -> Word48 -> Word48 # div :: Word48 -> Word48 -> Word48 # mod :: Word48 -> Word48 -> Word48 # quotRem :: Word48 -> Word48 -> (Word48, Word48) # divMod :: Word48 -> Word48 -> (Word48, Word48) # toInteger :: Word48 -> Integer #
Data Word48 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word48 -> c Word48 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word48 # toConstr :: Word48 -> Constr # dataTypeOf :: Word48 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word48) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word48) # gmapT :: (forall b. Data b => b -> b) -> Word48 -> Word48 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word48 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word48 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word48 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word48 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 #
Num Word48 Source #
Methods (+) :: Word48 -> Word48 -> Word48 # (-) :: Word48 -> Word48 -> Word48 # (*) :: Word48 -> Word48 -> Word48 # negate :: Word48 -> Word48 # abs :: Word48 -> Word48 # signum :: Word48 -> Word48 # fromInteger :: Integer -> Word48 #
Ord Word48 Source #
Methods compare :: Word48 -> Word48 -> Ordering # (<) :: Word48 -> Word48 -> Bool # (<=) :: Word48 -> Word48 -> Bool # (>) :: Word48 -> Word48 -> Bool # (>=) :: Word48 -> Word48 -> Bool # max :: Word48 -> Word48 -> Word48 # min :: Word48 -> Word48 -> Word48 #
Read Word48 Source #
Methods readsPrec :: Int -> ReadS Word48 # readList :: ReadS [Word48] # readPrec :: ReadPrec Word48 # readListPrec :: ReadPrec [Word48] #
Real Word48 Source #
Methods toRational :: Word48 -> Rational #
Show Word48 Source #
Methods showsPrec :: Int -> Word48 -> ShowS # show :: Word48 -> String # showList :: [Word48] -> ShowS #
Ix Word48 Source #
Methods range :: (Word48, Word48) -> [Word48] # index :: (Word48, Word48) -> Word48 -> Int # unsafeIndex :: (Word48, Word48) -> Word48 -> Int inRange :: (Word48, Word48) -> Word48 -> Bool # rangeSize :: (Word48, Word48) -> Int # unsafeRangeSize :: (Word48, Word48) -> Int
Bits Word48 Source #
Methods (.&.) :: Word48 -> Word48 -> Word48 # (.\|.) :: Word48 -> Word48 -> Word48 # xor :: Word48 -> Word48 -> Word48 # complement :: Word48 -> Word48 # shift :: Word48 -> Int -> Word48 # rotate :: Word48 -> Int -> Word48 # zeroBits :: Word48 # bit :: Int -> Word48 # setBit :: Word48 -> Int -> Word48 # clearBit :: Word48 -> Int -> Word48 # complementBit :: Word48 -> Int -> Word48 # testBit :: Word48 -> Int -> Bool # bitSizeMaybe :: Word48 -> Maybe Int # bitSize :: Word48 -> Int # isSigned :: Word48 -> Bool # shiftL :: Word48 -> Int -> Word48 # unsafeShiftL :: Word48 -> Int -> Word48 # shiftR :: Word48 -> Int -> Word48 # unsafeShiftR :: Word48 -> Int -> Word48 # rotateL :: Word48 -> Int -> Word48 # rotateR :: Word48 -> Int -> Word48 # popCount :: Word48 -> Int #
FiniteBits Word48 Source #
Methods finiteBitSize :: Word48 -> Int # countLeadingZeros :: Word48 -> Int # countTrailingZeros :: Word48 -> Int #
BinaryWord Word48 Source #
Associated Types type UnsignedWord Word48 :: * # type SignedWord Word48 :: * # Methods unsignedWord :: Word48 -> UnsignedWord Word48 # signedWord :: Word48 -> SignedWord Word48 # unwrappedAdd :: Word48 -> Word48 -> (Word48, UnsignedWord Word48) # unwrappedMul :: Word48 -> Word48 -> (Word48, UnsignedWord Word48) # leadingZeroes :: Word48 -> Int # trailingZeroes :: Word48 -> Int # allZeroes :: Word48 # allOnes :: Word48 # msb :: Word48 # lsb :: Word48 # testMsb :: Word48 -> Bool # testLsb :: Word48 -> Bool # setMsb :: Word48 -> Word48 # setLsb :: Word48 -> Word48 # clearMsb :: Word48 -> Word48 # clearLsb :: Word48 -> Word48 #
Hashable Word48 Source #
Methods hashWithSalt :: Int -> Word48 -> Int # hash :: Word48 -> Int #
type SignedWord Word48 Source #
type SignedWord Word48 = Int48
type UnsignedWord Word48 Source #
type UnsignedWord Word48 = Word48

aWord48 :: Proxy Word48 Source #

data Int2 Source #

Instances

Bounded Int2 Source #
Methods minBound :: Int2 # maxBound :: Int2 #
Enum Int2 Source #
Methods succ :: Int2 -> Int2 # pred :: Int2 -> Int2 # toEnum :: Int -> Int2 # fromEnum :: Int2 -> Int # enumFrom :: Int2 -> [Int2] # enumFromThen :: Int2 -> Int2 -> [Int2] # enumFromTo :: Int2 -> Int2 -> [Int2] # enumFromThenTo :: Int2 -> Int2 -> Int2 -> [Int2] #
Eq Int2 Source #
Methods (==) :: Int2 -> Int2 -> Bool # (/=) :: Int2 -> Int2 -> Bool #
Integral Int2 Source #
Methods quot :: Int2 -> Int2 -> Int2 # rem :: Int2 -> Int2 -> Int2 # div :: Int2 -> Int2 -> Int2 # mod :: Int2 -> Int2 -> Int2 # quotRem :: Int2 -> Int2 -> (Int2, Int2) # divMod :: Int2 -> Int2 -> (Int2, Int2) # toInteger :: Int2 -> Integer #
Data Int2 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int2 -> c Int2 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int2 # toConstr :: Int2 -> Constr # dataTypeOf :: Int2 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int2) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int2) # gmapT :: (forall b. Data b => b -> b) -> Int2 -> Int2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int2 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 #
Num Int2 Source #
Methods (+) :: Int2 -> Int2 -> Int2 # (-) :: Int2 -> Int2 -> Int2 # (*) :: Int2 -> Int2 -> Int2 # negate :: Int2 -> Int2 # abs :: Int2 -> Int2 # signum :: Int2 -> Int2 # fromInteger :: Integer -> Int2 #
Ord Int2 Source #
Methods compare :: Int2 -> Int2 -> Ordering # (<) :: Int2 -> Int2 -> Bool # (<=) :: Int2 -> Int2 -> Bool # (>) :: Int2 -> Int2 -> Bool # (>=) :: Int2 -> Int2 -> Bool # max :: Int2 -> Int2 -> Int2 # min :: Int2 -> Int2 -> Int2 #
Read Int2 Source #
Methods readsPrec :: Int -> ReadS Int2 # readList :: ReadS [Int2] # readPrec :: ReadPrec Int2 # readListPrec :: ReadPrec [Int2] #
Real Int2 Source #
Methods toRational :: Int2 -> Rational #
Show Int2 Source #
Methods showsPrec :: Int -> Int2 -> ShowS # show :: Int2 -> String # showList :: [Int2] -> ShowS #
Ix Int2 Source #
Methods range :: (Int2, Int2) -> [Int2] # index :: (Int2, Int2) -> Int2 -> Int # unsafeIndex :: (Int2, Int2) -> Int2 -> Int inRange :: (Int2, Int2) -> Int2 -> Bool # rangeSize :: (Int2, Int2) -> Int # unsafeRangeSize :: (Int2, Int2) -> Int
Bits Int2 Source #
Methods (.&.) :: Int2 -> Int2 -> Int2 # (.\|.) :: Int2 -> Int2 -> Int2 # xor :: Int2 -> Int2 -> Int2 # complement :: Int2 -> Int2 # shift :: Int2 -> Int -> Int2 # rotate :: Int2 -> Int -> Int2 # zeroBits :: Int2 # bit :: Int -> Int2 # setBit :: Int2 -> Int -> Int2 # clearBit :: Int2 -> Int -> Int2 # complementBit :: Int2 -> Int -> Int2 # testBit :: Int2 -> Int -> Bool # bitSizeMaybe :: Int2 -> Maybe Int # bitSize :: Int2 -> Int # isSigned :: Int2 -> Bool # shiftL :: Int2 -> Int -> Int2 # unsafeShiftL :: Int2 -> Int -> Int2 # shiftR :: Int2 -> Int -> Int2 # unsafeShiftR :: Int2 -> Int -> Int2 # rotateL :: Int2 -> Int -> Int2 # rotateR :: Int2 -> Int -> Int2 # popCount :: Int2 -> Int #
FiniteBits Int2 Source #
Methods finiteBitSize :: Int2 -> Int # countLeadingZeros :: Int2 -> Int # countTrailingZeros :: Int2 -> Int #
BinaryWord Int2 Source #
Associated Types type UnsignedWord Int2 :: * # type SignedWord Int2 :: * # Methods unsignedWord :: Int2 -> UnsignedWord Int2 # signedWord :: Int2 -> SignedWord Int2 # unwrappedAdd :: Int2 -> Int2 -> (Int2, UnsignedWord Int2) # unwrappedMul :: Int2 -> Int2 -> (Int2, UnsignedWord Int2) # leadingZeroes :: Int2 -> Int # trailingZeroes :: Int2 -> Int # allZeroes :: Int2 # allOnes :: Int2 # msb :: Int2 # lsb :: Int2 # testMsb :: Int2 -> Bool # testLsb :: Int2 -> Bool # setMsb :: Int2 -> Int2 # setLsb :: Int2 -> Int2 # clearMsb :: Int2 -> Int2 # clearLsb :: Int2 -> Int2 #
Hashable Int2 Source #
Methods hashWithSalt :: Int -> Int2 -> Int # hash :: Int2 -> Int #
type SignedWord Int2 Source #
type SignedWord Int2 = Int2
type UnsignedWord Int2 Source #
type UnsignedWord Int2 = Word2

anInt2 :: Proxy Int2 Source #

data Int3 Source #

Instances

Bounded Int3 Source #
Methods minBound :: Int3 # maxBound :: Int3 #
Enum Int3 Source #
Methods succ :: Int3 -> Int3 # pred :: Int3 -> Int3 # toEnum :: Int -> Int3 # fromEnum :: Int3 -> Int # enumFrom :: Int3 -> [Int3] # enumFromThen :: Int3 -> Int3 -> [Int3] # enumFromTo :: Int3 -> Int3 -> [Int3] # enumFromThenTo :: Int3 -> Int3 -> Int3 -> [Int3] #
Eq Int3 Source #
Methods (==) :: Int3 -> Int3 -> Bool # (/=) :: Int3 -> Int3 -> Bool #
Integral Int3 Source #
Methods quot :: Int3 -> Int3 -> Int3 # rem :: Int3 -> Int3 -> Int3 # div :: Int3 -> Int3 -> Int3 # mod :: Int3 -> Int3 -> Int3 # quotRem :: Int3 -> Int3 -> (Int3, Int3) # divMod :: Int3 -> Int3 -> (Int3, Int3) # toInteger :: Int3 -> Integer #
Data Int3 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int3 -> c Int3 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int3 # toConstr :: Int3 -> Constr # dataTypeOf :: Int3 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int3) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int3) # gmapT :: (forall b. Data b => b -> b) -> Int3 -> Int3 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int3 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int3 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int3 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int3 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int3 -> m Int3 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int3 -> m Int3 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int3 -> m Int3 #
Num Int3 Source #
Methods (+) :: Int3 -> Int3 -> Int3 # (-) :: Int3 -> Int3 -> Int3 # (*) :: Int3 -> Int3 -> Int3 # negate :: Int3 -> Int3 # abs :: Int3 -> Int3 # signum :: Int3 -> Int3 # fromInteger :: Integer -> Int3 #
Ord Int3 Source #
Methods compare :: Int3 -> Int3 -> Ordering # (<) :: Int3 -> Int3 -> Bool # (<=) :: Int3 -> Int3 -> Bool # (>) :: Int3 -> Int3 -> Bool # (>=) :: Int3 -> Int3 -> Bool # max :: Int3 -> Int3 -> Int3 # min :: Int3 -> Int3 -> Int3 #
Read Int3 Source #
Methods readsPrec :: Int -> ReadS Int3 # readList :: ReadS [Int3] # readPrec :: ReadPrec Int3 # readListPrec :: ReadPrec [Int3] #
Real Int3 Source #
Methods toRational :: Int3 -> Rational #
Show Int3 Source #
Methods showsPrec :: Int -> Int3 -> ShowS # show :: Int3 -> String # showList :: [Int3] -> ShowS #
Ix Int3 Source #
Methods range :: (Int3, Int3) -> [Int3] # index :: (Int3, Int3) -> Int3 -> Int # unsafeIndex :: (Int3, Int3) -> Int3 -> Int inRange :: (Int3, Int3) -> Int3 -> Bool # rangeSize :: (Int3, Int3) -> Int # unsafeRangeSize :: (Int3, Int3) -> Int
Bits Int3 Source #
Methods (.&.) :: Int3 -> Int3 -> Int3 # (.\|.) :: Int3 -> Int3 -> Int3 # xor :: Int3 -> Int3 -> Int3 # complement :: Int3 -> Int3 # shift :: Int3 -> Int -> Int3 # rotate :: Int3 -> Int -> Int3 # zeroBits :: Int3 # bit :: Int -> Int3 # setBit :: Int3 -> Int -> Int3 # clearBit :: Int3 -> Int -> Int3 # complementBit :: Int3 -> Int -> Int3 # testBit :: Int3 -> Int -> Bool # bitSizeMaybe :: Int3 -> Maybe Int # bitSize :: Int3 -> Int # isSigned :: Int3 -> Bool # shiftL :: Int3 -> Int -> Int3 # unsafeShiftL :: Int3 -> Int -> Int3 # shiftR :: Int3 -> Int -> Int3 # unsafeShiftR :: Int3 -> Int -> Int3 # rotateL :: Int3 -> Int -> Int3 # rotateR :: Int3 -> Int -> Int3 # popCount :: Int3 -> Int #
FiniteBits Int3 Source #
Methods finiteBitSize :: Int3 -> Int # countLeadingZeros :: Int3 -> Int # countTrailingZeros :: Int3 -> Int #
BinaryWord Int3 Source #
Associated Types type UnsignedWord Int3 :: * # type SignedWord Int3 :: * # Methods unsignedWord :: Int3 -> UnsignedWord Int3 # signedWord :: Int3 -> SignedWord Int3 # unwrappedAdd :: Int3 -> Int3 -> (Int3, UnsignedWord Int3) # unwrappedMul :: Int3 -> Int3 -> (Int3, UnsignedWord Int3) # leadingZeroes :: Int3 -> Int # trailingZeroes :: Int3 -> Int # allZeroes :: Int3 # allOnes :: Int3 # msb :: Int3 # lsb :: Int3 # testMsb :: Int3 -> Bool # testLsb :: Int3 -> Bool # setMsb :: Int3 -> Int3 # setLsb :: Int3 -> Int3 # clearMsb :: Int3 -> Int3 # clearLsb :: Int3 -> Int3 #
Hashable Int3 Source #
Methods hashWithSalt :: Int -> Int3 -> Int # hash :: Int3 -> Int #
type SignedWord Int3 Source #
type SignedWord Int3 = Int3
type UnsignedWord Int3 Source #
type UnsignedWord Int3 = Word3

anInt3 :: Proxy Int3 Source #

data Int4 Source #

Instances

Bounded Int4 Source #
Methods minBound :: Int4 # maxBound :: Int4 #
Enum Int4 Source #
Methods succ :: Int4 -> Int4 # pred :: Int4 -> Int4 # toEnum :: Int -> Int4 # fromEnum :: Int4 -> Int # enumFrom :: Int4 -> [Int4] # enumFromThen :: Int4 -> Int4 -> [Int4] # enumFromTo :: Int4 -> Int4 -> [Int4] # enumFromThenTo :: Int4 -> Int4 -> Int4 -> [Int4] #
Eq Int4 Source #
Methods (==) :: Int4 -> Int4 -> Bool # (/=) :: Int4 -> Int4 -> Bool #
Integral Int4 Source #
Methods quot :: Int4 -> Int4 -> Int4 # rem :: Int4 -> Int4 -> Int4 # div :: Int4 -> Int4 -> Int4 # mod :: Int4 -> Int4 -> Int4 # quotRem :: Int4 -> Int4 -> (Int4, Int4) # divMod :: Int4 -> Int4 -> (Int4, Int4) # toInteger :: Int4 -> Integer #
Data Int4 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int4 -> c Int4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int4 # toConstr :: Int4 -> Constr # dataTypeOf :: Int4 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int4) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int4) # gmapT :: (forall b. Data b => b -> b) -> Int4 -> Int4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int4 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 #
Num Int4 Source #
Methods (+) :: Int4 -> Int4 -> Int4 # (-) :: Int4 -> Int4 -> Int4 # (*) :: Int4 -> Int4 -> Int4 # negate :: Int4 -> Int4 # abs :: Int4 -> Int4 # signum :: Int4 -> Int4 # fromInteger :: Integer -> Int4 #
Ord Int4 Source #
Methods compare :: Int4 -> Int4 -> Ordering # (<) :: Int4 -> Int4 -> Bool # (<=) :: Int4 -> Int4 -> Bool # (>) :: Int4 -> Int4 -> Bool # (>=) :: Int4 -> Int4 -> Bool # max :: Int4 -> Int4 -> Int4 # min :: Int4 -> Int4 -> Int4 #
Read Int4 Source #
Methods readsPrec :: Int -> ReadS Int4 # readList :: ReadS [Int4] # readPrec :: ReadPrec Int4 # readListPrec :: ReadPrec [Int4] #
Real Int4 Source #
Methods toRational :: Int4 -> Rational #
Show Int4 Source #
Methods showsPrec :: Int -> Int4 -> ShowS # show :: Int4 -> String # showList :: [Int4] -> ShowS #
Ix Int4 Source #
Methods range :: (Int4, Int4) -> [Int4] # index :: (Int4, Int4) -> Int4 -> Int # unsafeIndex :: (Int4, Int4) -> Int4 -> Int inRange :: (Int4, Int4) -> Int4 -> Bool # rangeSize :: (Int4, Int4) -> Int # unsafeRangeSize :: (Int4, Int4) -> Int
Bits Int4 Source #
Methods (.&.) :: Int4 -> Int4 -> Int4 # (.\|.) :: Int4 -> Int4 -> Int4 # xor :: Int4 -> Int4 -> Int4 # complement :: Int4 -> Int4 # shift :: Int4 -> Int -> Int4 # rotate :: Int4 -> Int -> Int4 # zeroBits :: Int4 # bit :: Int -> Int4 # setBit :: Int4 -> Int -> Int4 # clearBit :: Int4 -> Int -> Int4 # complementBit :: Int4 -> Int -> Int4 # testBit :: Int4 -> Int -> Bool # bitSizeMaybe :: Int4 -> Maybe Int # bitSize :: Int4 -> Int # isSigned :: Int4 -> Bool # shiftL :: Int4 -> Int -> Int4 # unsafeShiftL :: Int4 -> Int -> Int4 # shiftR :: Int4 -> Int -> Int4 # unsafeShiftR :: Int4 -> Int -> Int4 # rotateL :: Int4 -> Int -> Int4 # rotateR :: Int4 -> Int -> Int4 # popCount :: Int4 -> Int #
FiniteBits Int4 Source #
Methods finiteBitSize :: Int4 -> Int # countLeadingZeros :: Int4 -> Int # countTrailingZeros :: Int4 -> Int #
BinaryWord Int4 Source #
Associated Types type UnsignedWord Int4 :: * # type SignedWord Int4 :: * # Methods unsignedWord :: Int4 -> UnsignedWord Int4 # signedWord :: Int4 -> SignedWord Int4 # unwrappedAdd :: Int4 -> Int4 -> (Int4, UnsignedWord Int4) # unwrappedMul :: Int4 -> Int4 -> (Int4, UnsignedWord Int4) # leadingZeroes :: Int4 -> Int # trailingZeroes :: Int4 -> Int # allZeroes :: Int4 # allOnes :: Int4 # msb :: Int4 # lsb :: Int4 # testMsb :: Int4 -> Bool # testLsb :: Int4 -> Bool # setMsb :: Int4 -> Int4 # setLsb :: Int4 -> Int4 # clearMsb :: Int4 -> Int4 # clearLsb :: Int4 -> Int4 #
Hashable Int4 Source #
Methods hashWithSalt :: Int -> Int4 -> Int # hash :: Int4 -> Int #
type SignedWord Int4 Source #
type SignedWord Int4 = Int4
type UnsignedWord Int4 Source #
type UnsignedWord Int4 = Word4

anInt4 :: Proxy Int4 Source #

data Int5 Source #

Instances

Bounded Int5 Source #
Methods minBound :: Int5 # maxBound :: Int5 #
Enum Int5 Source #
Methods succ :: Int5 -> Int5 # pred :: Int5 -> Int5 # toEnum :: Int -> Int5 # fromEnum :: Int5 -> Int # enumFrom :: Int5 -> [Int5] # enumFromThen :: Int5 -> Int5 -> [Int5] # enumFromTo :: Int5 -> Int5 -> [Int5] # enumFromThenTo :: Int5 -> Int5 -> Int5 -> [Int5] #
Eq Int5 Source #
Methods (==) :: Int5 -> Int5 -> Bool # (/=) :: Int5 -> Int5 -> Bool #
Integral Int5 Source #
Methods quot :: Int5 -> Int5 -> Int5 # rem :: Int5 -> Int5 -> Int5 # div :: Int5 -> Int5 -> Int5 # mod :: Int5 -> Int5 -> Int5 # quotRem :: Int5 -> Int5 -> (Int5, Int5) # divMod :: Int5 -> Int5 -> (Int5, Int5) # toInteger :: Int5 -> Integer #
Data Int5 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int5 -> c Int5 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int5 # toConstr :: Int5 -> Constr # dataTypeOf :: Int5 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int5) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int5) # gmapT :: (forall b. Data b => b -> b) -> Int5 -> Int5 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int5 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int5 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int5 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int5 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int5 -> m Int5 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int5 -> m Int5 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int5 -> m Int5 #
Num Int5 Source #
Methods (+) :: Int5 -> Int5 -> Int5 # (-) :: Int5 -> Int5 -> Int5 # (*) :: Int5 -> Int5 -> Int5 # negate :: Int5 -> Int5 # abs :: Int5 -> Int5 # signum :: Int5 -> Int5 # fromInteger :: Integer -> Int5 #
Ord Int5 Source #
Methods compare :: Int5 -> Int5 -> Ordering # (<) :: Int5 -> Int5 -> Bool # (<=) :: Int5 -> Int5 -> Bool # (>) :: Int5 -> Int5 -> Bool # (>=) :: Int5 -> Int5 -> Bool # max :: Int5 -> Int5 -> Int5 # min :: Int5 -> Int5 -> Int5 #
Read Int5 Source #
Methods readsPrec :: Int -> ReadS Int5 # readList :: ReadS [Int5] # readPrec :: ReadPrec Int5 # readListPrec :: ReadPrec [Int5] #
Real Int5 Source #
Methods toRational :: Int5 -> Rational #
Show Int5 Source #
Methods showsPrec :: Int -> Int5 -> ShowS # show :: Int5 -> String # showList :: [Int5] -> ShowS #
Ix Int5 Source #
Methods range :: (Int5, Int5) -> [Int5] # index :: (Int5, Int5) -> Int5 -> Int # unsafeIndex :: (Int5, Int5) -> Int5 -> Int inRange :: (Int5, Int5) -> Int5 -> Bool # rangeSize :: (Int5, Int5) -> Int # unsafeRangeSize :: (Int5, Int5) -> Int
Bits Int5 Source #
Methods (.&.) :: Int5 -> Int5 -> Int5 # (.\|.) :: Int5 -> Int5 -> Int5 # xor :: Int5 -> Int5 -> Int5 # complement :: Int5 -> Int5 # shift :: Int5 -> Int -> Int5 # rotate :: Int5 -> Int -> Int5 # zeroBits :: Int5 # bit :: Int -> Int5 # setBit :: Int5 -> Int -> Int5 # clearBit :: Int5 -> Int -> Int5 # complementBit :: Int5 -> Int -> Int5 # testBit :: Int5 -> Int -> Bool # bitSizeMaybe :: Int5 -> Maybe Int # bitSize :: Int5 -> Int # isSigned :: Int5 -> Bool # shiftL :: Int5 -> Int -> Int5 # unsafeShiftL :: Int5 -> Int -> Int5 # shiftR :: Int5 -> Int -> Int5 # unsafeShiftR :: Int5 -> Int -> Int5 # rotateL :: Int5 -> Int -> Int5 # rotateR :: Int5 -> Int -> Int5 # popCount :: Int5 -> Int #
FiniteBits Int5 Source #
Methods finiteBitSize :: Int5 -> Int # countLeadingZeros :: Int5 -> Int # countTrailingZeros :: Int5 -> Int #
BinaryWord Int5 Source #
Associated Types type UnsignedWord Int5 :: * # type SignedWord Int5 :: * # Methods unsignedWord :: Int5 -> UnsignedWord Int5 # signedWord :: Int5 -> SignedWord Int5 # unwrappedAdd :: Int5 -> Int5 -> (Int5, UnsignedWord Int5) # unwrappedMul :: Int5 -> Int5 -> (Int5, UnsignedWord Int5) # leadingZeroes :: Int5 -> Int # trailingZeroes :: Int5 -> Int # allZeroes :: Int5 # allOnes :: Int5 # msb :: Int5 # lsb :: Int5 # testMsb :: Int5 -> Bool # testLsb :: Int5 -> Bool # setMsb :: Int5 -> Int5 # setLsb :: Int5 -> Int5 # clearMsb :: Int5 -> Int5 # clearLsb :: Int5 -> Int5 #
Hashable Int5 Source #
Methods hashWithSalt :: Int -> Int5 -> Int # hash :: Int5 -> Int #
type SignedWord Int5 Source #
type SignedWord Int5 = Int5
type UnsignedWord Int5 Source #
type UnsignedWord Int5 = Word5

anInt5 :: Proxy Int5 Source #

data Int6 Source #

Instances

Bounded Int6 Source #
Methods minBound :: Int6 # maxBound :: Int6 #
Enum Int6 Source #
Methods succ :: Int6 -> Int6 # pred :: Int6 -> Int6 # toEnum :: Int -> Int6 # fromEnum :: Int6 -> Int # enumFrom :: Int6 -> [Int6] # enumFromThen :: Int6 -> Int6 -> [Int6] # enumFromTo :: Int6 -> Int6 -> [Int6] # enumFromThenTo :: Int6 -> Int6 -> Int6 -> [Int6] #
Eq Int6 Source #
Methods (==) :: Int6 -> Int6 -> Bool # (/=) :: Int6 -> Int6 -> Bool #
Integral Int6 Source #
Methods quot :: Int6 -> Int6 -> Int6 # rem :: Int6 -> Int6 -> Int6 # div :: Int6 -> Int6 -> Int6 # mod :: Int6 -> Int6 -> Int6 # quotRem :: Int6 -> Int6 -> (Int6, Int6) # divMod :: Int6 -> Int6 -> (Int6, Int6) # toInteger :: Int6 -> Integer #
Data Int6 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int6 -> c Int6 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int6 # toConstr :: Int6 -> Constr # dataTypeOf :: Int6 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int6) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int6) # gmapT :: (forall b. Data b => b -> b) -> Int6 -> Int6 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int6 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int6 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int6 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int6 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int6 -> m Int6 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int6 -> m Int6 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int6 -> m Int6 #
Num Int6 Source #
Methods (+) :: Int6 -> Int6 -> Int6 # (-) :: Int6 -> Int6 -> Int6 # (*) :: Int6 -> Int6 -> Int6 # negate :: Int6 -> Int6 # abs :: Int6 -> Int6 # signum :: Int6 -> Int6 # fromInteger :: Integer -> Int6 #
Ord Int6 Source #
Methods compare :: Int6 -> Int6 -> Ordering # (<) :: Int6 -> Int6 -> Bool # (<=) :: Int6 -> Int6 -> Bool # (>) :: Int6 -> Int6 -> Bool # (>=) :: Int6 -> Int6 -> Bool # max :: Int6 -> Int6 -> Int6 # min :: Int6 -> Int6 -> Int6 #
Read Int6 Source #
Methods readsPrec :: Int -> ReadS Int6 # readList :: ReadS [Int6] # readPrec :: ReadPrec Int6 # readListPrec :: ReadPrec [Int6] #
Real Int6 Source #
Methods toRational :: Int6 -> Rational #
Show Int6 Source #
Methods showsPrec :: Int -> Int6 -> ShowS # show :: Int6 -> String # showList :: [Int6] -> ShowS #
Ix Int6 Source #
Methods range :: (Int6, Int6) -> [Int6] # index :: (Int6, Int6) -> Int6 -> Int # unsafeIndex :: (Int6, Int6) -> Int6 -> Int inRange :: (Int6, Int6) -> Int6 -> Bool # rangeSize :: (Int6, Int6) -> Int # unsafeRangeSize :: (Int6, Int6) -> Int
Bits Int6 Source #
Methods (.&.) :: Int6 -> Int6 -> Int6 # (.\|.) :: Int6 -> Int6 -> Int6 # xor :: Int6 -> Int6 -> Int6 # complement :: Int6 -> Int6 # shift :: Int6 -> Int -> Int6 # rotate :: Int6 -> Int -> Int6 # zeroBits :: Int6 # bit :: Int -> Int6 # setBit :: Int6 -> Int -> Int6 # clearBit :: Int6 -> Int -> Int6 # complementBit :: Int6 -> Int -> Int6 # testBit :: Int6 -> Int -> Bool # bitSizeMaybe :: Int6 -> Maybe Int # bitSize :: Int6 -> Int # isSigned :: Int6 -> Bool # shiftL :: Int6 -> Int -> Int6 # unsafeShiftL :: Int6 -> Int -> Int6 # shiftR :: Int6 -> Int -> Int6 # unsafeShiftR :: Int6 -> Int -> Int6 # rotateL :: Int6 -> Int -> Int6 # rotateR :: Int6 -> Int -> Int6 # popCount :: Int6 -> Int #
FiniteBits Int6 Source #
Methods finiteBitSize :: Int6 -> Int # countLeadingZeros :: Int6 -> Int # countTrailingZeros :: Int6 -> Int #
BinaryWord Int6 Source #
Associated Types type UnsignedWord Int6 :: * # type SignedWord Int6 :: * # Methods unsignedWord :: Int6 -> UnsignedWord Int6 # signedWord :: Int6 -> SignedWord Int6 # unwrappedAdd :: Int6 -> Int6 -> (Int6, UnsignedWord Int6) # unwrappedMul :: Int6 -> Int6 -> (Int6, UnsignedWord Int6) # leadingZeroes :: Int6 -> Int # trailingZeroes :: Int6 -> Int # allZeroes :: Int6 # allOnes :: Int6 # msb :: Int6 # lsb :: Int6 # testMsb :: Int6 -> Bool # testLsb :: Int6 -> Bool # setMsb :: Int6 -> Int6 # setLsb :: Int6 -> Int6 # clearMsb :: Int6 -> Int6 # clearLsb :: Int6 -> Int6 #
Hashable Int6 Source #
Methods hashWithSalt :: Int -> Int6 -> Int # hash :: Int6 -> Int #
type SignedWord Int6 Source #
type SignedWord Int6 = Int6
type UnsignedWord Int6 Source #
type UnsignedWord Int6 = Word6

anInt6 :: Proxy Int6 Source #

data Int7 Source #

Instances

Bounded Int7 Source #
Methods minBound :: Int7 # maxBound :: Int7 #
Enum Int7 Source #
Methods succ :: Int7 -> Int7 # pred :: Int7 -> Int7 # toEnum :: Int -> Int7 # fromEnum :: Int7 -> Int # enumFrom :: Int7 -> [Int7] # enumFromThen :: Int7 -> Int7 -> [Int7] # enumFromTo :: Int7 -> Int7 -> [Int7] # enumFromThenTo :: Int7 -> Int7 -> Int7 -> [Int7] #
Eq Int7 Source #
Methods (==) :: Int7 -> Int7 -> Bool # (/=) :: Int7 -> Int7 -> Bool #
Integral Int7 Source #
Methods quot :: Int7 -> Int7 -> Int7 # rem :: Int7 -> Int7 -> Int7 # div :: Int7 -> Int7 -> Int7 # mod :: Int7 -> Int7 -> Int7 # quotRem :: Int7 -> Int7 -> (Int7, Int7) # divMod :: Int7 -> Int7 -> (Int7, Int7) # toInteger :: Int7 -> Integer #
Data Int7 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int7 -> c Int7 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int7 # toConstr :: Int7 -> Constr # dataTypeOf :: Int7 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int7) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int7) # gmapT :: (forall b. Data b => b -> b) -> Int7 -> Int7 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int7 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int7 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int7 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int7 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 #
Num Int7 Source #
Methods (+) :: Int7 -> Int7 -> Int7 # (-) :: Int7 -> Int7 -> Int7 # (*) :: Int7 -> Int7 -> Int7 # negate :: Int7 -> Int7 # abs :: Int7 -> Int7 # signum :: Int7 -> Int7 # fromInteger :: Integer -> Int7 #
Ord Int7 Source #
Methods compare :: Int7 -> Int7 -> Ordering # (<) :: Int7 -> Int7 -> Bool # (<=) :: Int7 -> Int7 -> Bool # (>) :: Int7 -> Int7 -> Bool # (>=) :: Int7 -> Int7 -> Bool # max :: Int7 -> Int7 -> Int7 # min :: Int7 -> Int7 -> Int7 #
Read Int7 Source #
Methods readsPrec :: Int -> ReadS Int7 # readList :: ReadS [Int7] # readPrec :: ReadPrec Int7 # readListPrec :: ReadPrec [Int7] #
Real Int7 Source #
Methods toRational :: Int7 -> Rational #
Show Int7 Source #
Methods showsPrec :: Int -> Int7 -> ShowS # show :: Int7 -> String # showList :: [Int7] -> ShowS #
Ix Int7 Source #
Methods range :: (Int7, Int7) -> [Int7] # index :: (Int7, Int7) -> Int7 -> Int # unsafeIndex :: (Int7, Int7) -> Int7 -> Int inRange :: (Int7, Int7) -> Int7 -> Bool # rangeSize :: (Int7, Int7) -> Int # unsafeRangeSize :: (Int7, Int7) -> Int
Bits Int7 Source #
Methods (.&.) :: Int7 -> Int7 -> Int7 # (.\|.) :: Int7 -> Int7 -> Int7 # xor :: Int7 -> Int7 -> Int7 # complement :: Int7 -> Int7 # shift :: Int7 -> Int -> Int7 # rotate :: Int7 -> Int -> Int7 # zeroBits :: Int7 # bit :: Int -> Int7 # setBit :: Int7 -> Int -> Int7 # clearBit :: Int7 -> Int -> Int7 # complementBit :: Int7 -> Int -> Int7 # testBit :: Int7 -> Int -> Bool # bitSizeMaybe :: Int7 -> Maybe Int # bitSize :: Int7 -> Int # isSigned :: Int7 -> Bool # shiftL :: Int7 -> Int -> Int7 # unsafeShiftL :: Int7 -> Int -> Int7 # shiftR :: Int7 -> Int -> Int7 # unsafeShiftR :: Int7 -> Int -> Int7 # rotateL :: Int7 -> Int -> Int7 # rotateR :: Int7 -> Int -> Int7 # popCount :: Int7 -> Int #
FiniteBits Int7 Source #
Methods finiteBitSize :: Int7 -> Int # countLeadingZeros :: Int7 -> Int # countTrailingZeros :: Int7 -> Int #
BinaryWord Int7 Source #
Associated Types type UnsignedWord Int7 :: * # type SignedWord Int7 :: * # Methods unsignedWord :: Int7 -> UnsignedWord Int7 # signedWord :: Int7 -> SignedWord Int7 # unwrappedAdd :: Int7 -> Int7 -> (Int7, UnsignedWord Int7) # unwrappedMul :: Int7 -> Int7 -> (Int7, UnsignedWord Int7) # leadingZeroes :: Int7 -> Int # trailingZeroes :: Int7 -> Int # allZeroes :: Int7 # allOnes :: Int7 # msb :: Int7 # lsb :: Int7 # testMsb :: Int7 -> Bool # testLsb :: Int7 -> Bool # setMsb :: Int7 -> Int7 # setLsb :: Int7 -> Int7 # clearMsb :: Int7 -> Int7 # clearLsb :: Int7 -> Int7 #
Hashable Int7 Source #
Methods hashWithSalt :: Int -> Int7 -> Int # hash :: Int7 -> Int #
type SignedWord Int7 Source #
type SignedWord Int7 = Int7
type UnsignedWord Int7 Source #
type UnsignedWord Int7 = Word7

anInt7 :: Proxy Int7 Source #

data Int24 Source #

Instances

Bounded Int24 Source #
Methods minBound :: Int24 # maxBound :: Int24 #
Enum Int24 Source #
Methods succ :: Int24 -> Int24 # pred :: Int24 -> Int24 # toEnum :: Int -> Int24 # fromEnum :: Int24 -> Int # enumFrom :: Int24 -> [Int24] # enumFromThen :: Int24 -> Int24 -> [Int24] # enumFromTo :: Int24 -> Int24 -> [Int24] # enumFromThenTo :: Int24 -> Int24 -> Int24 -> [Int24] #
Eq Int24 Source #
Methods (==) :: Int24 -> Int24 -> Bool # (/=) :: Int24 -> Int24 -> Bool #
Integral Int24 Source #
Methods quot :: Int24 -> Int24 -> Int24 # rem :: Int24 -> Int24 -> Int24 # div :: Int24 -> Int24 -> Int24 # mod :: Int24 -> Int24 -> Int24 # quotRem :: Int24 -> Int24 -> (Int24, Int24) # divMod :: Int24 -> Int24 -> (Int24, Int24) # toInteger :: Int24 -> Integer #
Data Int24 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int24 -> c Int24 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int24 # toConstr :: Int24 -> Constr # dataTypeOf :: Int24 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int24) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int24) # gmapT :: (forall b. Data b => b -> b) -> Int24 -> Int24 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int24 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int24 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int24 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int24 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 #
Num Int24 Source #
Methods (+) :: Int24 -> Int24 -> Int24 # (-) :: Int24 -> Int24 -> Int24 # (*) :: Int24 -> Int24 -> Int24 # negate :: Int24 -> Int24 # abs :: Int24 -> Int24 # signum :: Int24 -> Int24 # fromInteger :: Integer -> Int24 #
Ord Int24 Source #
Methods compare :: Int24 -> Int24 -> Ordering # (<) :: Int24 -> Int24 -> Bool # (<=) :: Int24 -> Int24 -> Bool # (>) :: Int24 -> Int24 -> Bool # (>=) :: Int24 -> Int24 -> Bool # max :: Int24 -> Int24 -> Int24 # min :: Int24 -> Int24 -> Int24 #
Read Int24 Source #
Methods readsPrec :: Int -> ReadS Int24 # readList :: ReadS [Int24] # readPrec :: ReadPrec Int24 # readListPrec :: ReadPrec [Int24] #
Real Int24 Source #
Methods toRational :: Int24 -> Rational #
Show Int24 Source #
Methods showsPrec :: Int -> Int24 -> ShowS # show :: Int24 -> String # showList :: [Int24] -> ShowS #
Ix Int24 Source #
Methods range :: (Int24, Int24) -> [Int24] # index :: (Int24, Int24) -> Int24 -> Int # unsafeIndex :: (Int24, Int24) -> Int24 -> Int inRange :: (Int24, Int24) -> Int24 -> Bool # rangeSize :: (Int24, Int24) -> Int # unsafeRangeSize :: (Int24, Int24) -> Int
Bits Int24 Source #
Methods (.&.) :: Int24 -> Int24 -> Int24 # (.\|.) :: Int24 -> Int24 -> Int24 # xor :: Int24 -> Int24 -> Int24 # complement :: Int24 -> Int24 # shift :: Int24 -> Int -> Int24 # rotate :: Int24 -> Int -> Int24 # zeroBits :: Int24 # bit :: Int -> Int24 # setBit :: Int24 -> Int -> Int24 # clearBit :: Int24 -> Int -> Int24 # complementBit :: Int24 -> Int -> Int24 # testBit :: Int24 -> Int -> Bool # bitSizeMaybe :: Int24 -> Maybe Int # bitSize :: Int24 -> Int # isSigned :: Int24 -> Bool # shiftL :: Int24 -> Int -> Int24 # unsafeShiftL :: Int24 -> Int -> Int24 # shiftR :: Int24 -> Int -> Int24 # unsafeShiftR :: Int24 -> Int -> Int24 # rotateL :: Int24 -> Int -> Int24 # rotateR :: Int24 -> Int -> Int24 # popCount :: Int24 -> Int #
FiniteBits Int24 Source #
Methods finiteBitSize :: Int24 -> Int # countLeadingZeros :: Int24 -> Int # countTrailingZeros :: Int24 -> Int #
BinaryWord Int24 Source #
Associated Types type UnsignedWord Int24 :: * # type SignedWord Int24 :: * # Methods unsignedWord :: Int24 -> UnsignedWord Int24 # signedWord :: Int24 -> SignedWord Int24 # unwrappedAdd :: Int24 -> Int24 -> (Int24, UnsignedWord Int24) # unwrappedMul :: Int24 -> Int24 -> (Int24, UnsignedWord Int24) # leadingZeroes :: Int24 -> Int # trailingZeroes :: Int24 -> Int # allZeroes :: Int24 # allOnes :: Int24 # msb :: Int24 # lsb :: Int24 # testMsb :: Int24 -> Bool # testLsb :: Int24 -> Bool # setMsb :: Int24 -> Int24 # setLsb :: Int24 -> Int24 # clearMsb :: Int24 -> Int24 # clearLsb :: Int24 -> Int24 #
Hashable Int24 Source #
Methods hashWithSalt :: Int -> Int24 -> Int # hash :: Int24 -> Int #
type SignedWord Int24 Source #
type SignedWord Int24 = Int24
type UnsignedWord Int24 Source #
type UnsignedWord Int24 = Word24

anInt24 :: Proxy Int24 Source #

data Int48 Source #

Instances

Bounded Int48 Source #
Methods minBound :: Int48 # maxBound :: Int48 #
Enum Int48 Source #
Methods succ :: Int48 -> Int48 # pred :: Int48 -> Int48 # toEnum :: Int -> Int48 # fromEnum :: Int48 -> Int # enumFrom :: Int48 -> [Int48] # enumFromThen :: Int48 -> Int48 -> [Int48] # enumFromTo :: Int48 -> Int48 -> [Int48] # enumFromThenTo :: Int48 -> Int48 -> Int48 -> [Int48] #
Eq Int48 Source #
Methods (==) :: Int48 -> Int48 -> Bool # (/=) :: Int48 -> Int48 -> Bool #
Integral Int48 Source #
Methods quot :: Int48 -> Int48 -> Int48 # rem :: Int48 -> Int48 -> Int48 # div :: Int48 -> Int48 -> Int48 # mod :: Int48 -> Int48 -> Int48 # quotRem :: Int48 -> Int48 -> (Int48, Int48) # divMod :: Int48 -> Int48 -> (Int48, Int48) # toInteger :: Int48 -> Integer #
Data Int48 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int48 -> c Int48 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int48 # toConstr :: Int48 -> Constr # dataTypeOf :: Int48 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int48) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int48) # gmapT :: (forall b. Data b => b -> b) -> Int48 -> Int48 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int48 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int48 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int48 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int48 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 #
Num Int48 Source #
Methods (+) :: Int48 -> Int48 -> Int48 # (-) :: Int48 -> Int48 -> Int48 # (*) :: Int48 -> Int48 -> Int48 # negate :: Int48 -> Int48 # abs :: Int48 -> Int48 # signum :: Int48 -> Int48 # fromInteger :: Integer -> Int48 #
Ord Int48 Source #
Methods compare :: Int48 -> Int48 -> Ordering # (<) :: Int48 -> Int48 -> Bool # (<=) :: Int48 -> Int48 -> Bool # (>) :: Int48 -> Int48 -> Bool # (>=) :: Int48 -> Int48 -> Bool # max :: Int48 -> Int48 -> Int48 # min :: Int48 -> Int48 -> Int48 #
Read Int48 Source #
Methods readsPrec :: Int -> ReadS Int48 # readList :: ReadS [Int48] # readPrec :: ReadPrec Int48 # readListPrec :: ReadPrec [Int48] #
Real Int48 Source #
Methods toRational :: Int48 -> Rational #
Show Int48 Source #
Methods showsPrec :: Int -> Int48 -> ShowS # show :: Int48 -> String # showList :: [Int48] -> ShowS #
Ix Int48 Source #
Methods range :: (Int48, Int48) -> [Int48] # index :: (Int48, Int48) -> Int48 -> Int # unsafeIndex :: (Int48, Int48) -> Int48 -> Int inRange :: (Int48, Int48) -> Int48 -> Bool # rangeSize :: (Int48, Int48) -> Int # unsafeRangeSize :: (Int48, Int48) -> Int
Bits Int48 Source #
Methods (.&.) :: Int48 -> Int48 -> Int48 # (.\|.) :: Int48 -> Int48 -> Int48 # xor :: Int48 -> Int48 -> Int48 # complement :: Int48 -> Int48 # shift :: Int48 -> Int -> Int48 # rotate :: Int48 -> Int -> Int48 # zeroBits :: Int48 # bit :: Int -> Int48 # setBit :: Int48 -> Int -> Int48 # clearBit :: Int48 -> Int -> Int48 # complementBit :: Int48 -> Int -> Int48 # testBit :: Int48 -> Int -> Bool # bitSizeMaybe :: Int48 -> Maybe Int # bitSize :: Int48 -> Int # isSigned :: Int48 -> Bool # shiftL :: Int48 -> Int -> Int48 # unsafeShiftL :: Int48 -> Int -> Int48 # shiftR :: Int48 -> Int -> Int48 # unsafeShiftR :: Int48 -> Int -> Int48 # rotateL :: Int48 -> Int -> Int48 # rotateR :: Int48 -> Int -> Int48 # popCount :: Int48 -> Int #
FiniteBits Int48 Source #
Methods finiteBitSize :: Int48 -> Int # countLeadingZeros :: Int48 -> Int # countTrailingZeros :: Int48 -> Int #
BinaryWord Int48 Source #
Associated Types type UnsignedWord Int48 :: * # type SignedWord Int48 :: * # Methods unsignedWord :: Int48 -> UnsignedWord Int48 # signedWord :: Int48 -> SignedWord Int48 # unwrappedAdd :: Int48 -> Int48 -> (Int48, UnsignedWord Int48) # unwrappedMul :: Int48 -> Int48 -> (Int48, UnsignedWord Int48) # leadingZeroes :: Int48 -> Int # trailingZeroes :: Int48 -> Int # allZeroes :: Int48 # allOnes :: Int48 # msb :: Int48 # lsb :: Int48 # testMsb :: Int48 -> Bool # testLsb :: Int48 -> Bool # setMsb :: Int48 -> Int48 # setLsb :: Int48 -> Int48 # clearMsb :: Int48 -> Int48 # clearLsb :: Int48 -> Int48 #
Hashable Int48 Source #
Methods hashWithSalt :: Int -> Int48 -> Int # hash :: Int48 -> Int #
type SignedWord Int48 Source #
type SignedWord Int48 = Int48
type UnsignedWord Int48 Source #
type UnsignedWord Int48 = Word48

anInt48 :: Proxy Int48 Source #