Data.Word

Unsigned integer types.

Unsigned integral types

data Word :: *

A Word is an unsigned integral type, with the same size as Int.

Instances

Bounded Word

Methods

minBound :: Word

maxBound :: Word

Enum Word

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Eq Word

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Data Word

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word

toConstr :: Word -> Constr

dataTypeOf :: Word -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word)

gmapT :: (forall b. Data b => b -> b) -> Word -> Word

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

Num Word

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Read Word

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Methods

toRational :: Word -> Rational

Show Word

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word

Methods

range :: (Word, Word) -> [Word]

index :: (Word, Word) -> Word -> Int

unsafeIndex :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

FiniteBits Word

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

Bits Word

Methods

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

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

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

Storable Word

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

peekElemOff :: Ptr Word -> Int -> IO Word

pokeElemOff :: Ptr Word -> Int -> Word -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word

pokeByteOff :: Ptr b -> Int -> Word -> IO ()

peek :: Ptr Word -> IO Word

poke :: Ptr Word -> Word -> IO ()

PrintfArg Word

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Functor (URec Word)

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Foldable (URec Word)

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Traversable (URec Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b)

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a)

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b)

sequence :: Monad m => URec Word (m a) -> m (URec Word a)

Generic1 (URec Word)

Associated Types

type Rep1 (URec Word :: * -> *) :: * -> *

Methods

from1 :: URec Word a -> Rep1 (URec Word) a

to1 :: Rep1 (URec Word) a -> URec Word a

Eq (URec Word p)

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

Ord (URec Word p)

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

Show (URec Word p)

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> *

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

data URec Word

Used for marking occurrences of Word#

data URec Word = UWord {

• uWord# :: Word#

}

type Rep1 (URec Word)

type Rep1 (URec Word) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))

type Rep (URec Word p)

type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))

data Word8

8-bit unsigned integer type

Instances

Bounded Word8

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Eq Word8

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Data Word8

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8

toConstr :: Word8 -> Constr

dataTypeOf :: Word8 -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word8)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8)

gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r

gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

Num Word8

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Ord Word8

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Read Word8

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Methods

toRational :: Word8 -> Rational

Show Word8

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

unsafeIndex :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

FiniteBits Word8

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

Bits Word8

Methods

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

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

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

Storable Word8

Methods

sizeOf :: Word8 -> Int

alignment :: Word8 -> Int

peekElemOff :: Ptr Word8 -> Int -> IO Word8

pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word8

pokeByteOff :: Ptr b -> Int -> Word8 -> IO ()

peek :: Ptr Word8 -> IO Word8

poke :: Ptr Word8 -> Word8 -> IO ()

PrintfArg Word8

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

data Word16

16-bit unsigned integer type

Instances

Bounded Word16

Methods

minBound :: Word16

maxBound :: Word16

Enum Word16

Methods

succ :: Word16 -> Word16

pred :: Word16 -> Word16

toEnum :: Int -> Word16

fromEnum :: Word16 -> Int

enumFrom :: Word16 -> [Word16]

enumFromThen :: Word16 -> Word16 -> [Word16]

enumFromTo :: Word16 -> Word16 -> [Word16]

enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16]

Eq Word16

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Integral Word16

Methods

quot :: Word16 -> Word16 -> Word16

rem :: Word16 -> Word16 -> Word16

div :: Word16 -> Word16 -> Word16

mod :: Word16 -> Word16 -> Word16

quotRem :: Word16 -> Word16 -> (Word16, Word16)

divMod :: Word16 -> Word16 -> (Word16, Word16)

toInteger :: Word16 -> Integer

Data Word16

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16

toConstr :: Word16 -> Constr

dataTypeOf :: Word16 -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word16)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16)

gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r

gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16

Num Word16

Methods

(+) :: Word16 -> Word16 -> Word16

(-) :: Word16 -> Word16 -> Word16

(*) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Ord Word16

Methods

compare :: Word16 -> Word16 -> Ordering

(<) :: Word16 -> Word16 -> Bool

(<=) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(>=) :: Word16 -> Word16 -> Bool

max :: Word16 -> Word16 -> Word16

min :: Word16 -> Word16 -> Word16

Read Word16

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Real Word16

Methods

toRational :: Word16 -> Rational

Show Word16

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Ix Word16

Methods

range :: (Word16, Word16) -> [Word16]

index :: (Word16, Word16) -> Word16 -> Int

unsafeIndex :: (Word16, Word16) -> Word16 -> Int

inRange :: (Word16, Word16) -> Word16 -> Bool

rangeSize :: (Word16, Word16) -> Int

unsafeRangeSize :: (Word16, Word16) -> Int

FiniteBits Word16

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

Bits Word16

Methods

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

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

xor :: Word16 -> Word16 -> Word16

complement :: Word16 -> Word16

shift :: Word16 -> Int -> Word16

rotate :: Word16 -> Int -> Word16

zeroBits :: Word16

bit :: Int -> Word16

setBit :: Word16 -> Int -> Word16

clearBit :: Word16 -> Int -> Word16

complementBit :: Word16 -> Int -> Word16

testBit :: Word16 -> Int -> Bool

bitSizeMaybe :: Word16 -> Maybe Int

bitSize :: Word16 -> Int

isSigned :: Word16 -> Bool

shiftL :: Word16 -> Int -> Word16

unsafeShiftL :: Word16 -> Int -> Word16

shiftR :: Word16 -> Int -> Word16

unsafeShiftR :: Word16 -> Int -> Word16

rotateL :: Word16 -> Int -> Word16

rotateR :: Word16 -> Int -> Word16

popCount :: Word16 -> Int

Storable Word16

Methods

sizeOf :: Word16 -> Int

alignment :: Word16 -> Int

peekElemOff :: Ptr Word16 -> Int -> IO Word16

pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word16

pokeByteOff :: Ptr b -> Int -> Word16 -> IO ()

peek :: Ptr Word16 -> IO Word16

poke :: Ptr Word16 -> Word16 -> IO ()

PrintfArg Word16

Methods

formatArg :: Word16 -> FieldFormatter

parseFormat :: Word16 -> ModifierParser

data Word32

32-bit unsigned integer type

Instances

Bounded Word32

Methods

minBound :: Word32

maxBound :: Word32

Enum Word32

Methods

succ :: Word32 -> Word32

pred :: Word32 -> Word32

toEnum :: Int -> Word32

fromEnum :: Word32 -> Int

enumFrom :: Word32 -> [Word32]

enumFromThen :: Word32 -> Word32 -> [Word32]

enumFromTo :: Word32 -> Word32 -> [Word32]

enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32]

Eq Word32

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Integral Word32

Methods

quot :: Word32 -> Word32 -> Word32

rem :: Word32 -> Word32 -> Word32

div :: Word32 -> Word32 -> Word32

mod :: Word32 -> Word32 -> Word32

quotRem :: Word32 -> Word32 -> (Word32, Word32)

divMod :: Word32 -> Word32 -> (Word32, Word32)

toInteger :: Word32 -> Integer

Data Word32

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32

toConstr :: Word32 -> Constr

dataTypeOf :: Word32 -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word32)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32)

gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r

gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32

Num Word32

Methods

(+) :: Word32 -> Word32 -> Word32

(-) :: Word32 -> Word32 -> Word32

(*) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Ord Word32

Methods

compare :: Word32 -> Word32 -> Ordering

(<) :: Word32 -> Word32 -> Bool

(<=) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(>=) :: Word32 -> Word32 -> Bool

max :: Word32 -> Word32 -> Word32

min :: Word32 -> Word32 -> Word32

Read Word32

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Real Word32

Methods

toRational :: Word32 -> Rational

Show Word32

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Ix Word32

Methods

range :: (Word32, Word32) -> [Word32]

index :: (Word32, Word32) -> Word32 -> Int

unsafeIndex :: (Word32, Word32) -> Word32 -> Int

inRange :: (Word32, Word32) -> Word32 -> Bool

rangeSize :: (Word32, Word32) -> Int

unsafeRangeSize :: (Word32, Word32) -> Int

FiniteBits Word32

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

Bits Word32

Methods

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

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

xor :: Word32 -> Word32 -> Word32

complement :: Word32 -> Word32

shift :: Word32 -> Int -> Word32

rotate :: Word32 -> Int -> Word32

zeroBits :: Word32

bit :: Int -> Word32

setBit :: Word32 -> Int -> Word32

clearBit :: Word32 -> Int -> Word32

complementBit :: Word32 -> Int -> Word32

testBit :: Word32 -> Int -> Bool

bitSizeMaybe :: Word32 -> Maybe Int

bitSize :: Word32 -> Int

isSigned :: Word32 -> Bool

shiftL :: Word32 -> Int -> Word32

unsafeShiftL :: Word32 -> Int -> Word32

shiftR :: Word32 -> Int -> Word32

unsafeShiftR :: Word32 -> Int -> Word32

rotateL :: Word32 -> Int -> Word32

rotateR :: Word32 -> Int -> Word32

popCount :: Word32 -> Int

Storable Word32

Methods

sizeOf :: Word32 -> Int

alignment :: Word32 -> Int

peekElemOff :: Ptr Word32 -> Int -> IO Word32

pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word32

pokeByteOff :: Ptr b -> Int -> Word32 -> IO ()

peek :: Ptr Word32 -> IO Word32

poke :: Ptr Word32 -> Word32 -> IO ()

PrintfArg Word32

Methods

formatArg :: Word32 -> FieldFormatter

parseFormat :: Word32 -> ModifierParser

data Word64

64-bit unsigned integer type

Instances

Bounded Word64

Methods

minBound :: Word64

maxBound :: Word64

Enum Word64

Methods

succ :: Word64 -> Word64

pred :: Word64 -> Word64

toEnum :: Int -> Word64

fromEnum :: Word64 -> Int

enumFrom :: Word64 -> [Word64]

enumFromThen :: Word64 -> Word64 -> [Word64]

enumFromTo :: Word64 -> Word64 -> [Word64]

enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]

Eq Word64

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Integral Word64

Methods

quot :: Word64 -> Word64 -> Word64

rem :: Word64 -> Word64 -> Word64

div :: Word64 -> Word64 -> Word64

mod :: Word64 -> Word64 -> Word64

quotRem :: Word64 -> Word64 -> (Word64, Word64)

divMod :: Word64 -> Word64 -> (Word64, Word64)

toInteger :: Word64 -> Integer

Data Word64

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64

toConstr :: Word64 -> Constr

dataTypeOf :: Word64 -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word64)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64)

gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r

gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64

Num Word64

Methods

(+) :: Word64 -> Word64 -> Word64

(-) :: Word64 -> Word64 -> Word64

(*) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Ord Word64

Methods

compare :: Word64 -> Word64 -> Ordering

(<) :: Word64 -> Word64 -> Bool

(<=) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(>=) :: Word64 -> Word64 -> Bool

max :: Word64 -> Word64 -> Word64

min :: Word64 -> Word64 -> Word64

Read Word64

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Real Word64

Methods

toRational :: Word64 -> Rational

Show Word64

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Ix Word64

Methods

range :: (Word64, Word64) -> [Word64]

index :: (Word64, Word64) -> Word64 -> Int

unsafeIndex :: (Word64, Word64) -> Word64 -> Int

inRange :: (Word64, Word64) -> Word64 -> Bool

rangeSize :: (Word64, Word64) -> Int

unsafeRangeSize :: (Word64, Word64) -> Int

FiniteBits Word64

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

Bits Word64

Methods

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

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

xor :: Word64 -> Word64 -> Word64

complement :: Word64 -> Word64

shift :: Word64 -> Int -> Word64

rotate :: Word64 -> Int -> Word64

zeroBits :: Word64

bit :: Int -> Word64

setBit :: Word64 -> Int -> Word64

clearBit :: Word64 -> Int -> Word64

complementBit :: Word64 -> Int -> Word64

testBit :: Word64 -> Int -> Bool

bitSizeMaybe :: Word64 -> Maybe Int

bitSize :: Word64 -> Int

isSigned :: Word64 -> Bool

shiftL :: Word64 -> Int -> Word64

unsafeShiftL :: Word64 -> Int -> Word64

shiftR :: Word64 -> Int -> Word64

unsafeShiftR :: Word64 -> Int -> Word64

rotateL :: Word64 -> Int -> Word64

rotateR :: Word64 -> Int -> Word64

popCount :: Word64 -> Int

Storable Word64

Methods

sizeOf :: Word64 -> Int

alignment :: Word64 -> Int

peekElemOff :: Ptr Word64 -> Int -> IO Word64

pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word64

pokeByteOff :: Ptr b -> Int -> Word64 -> IO ()

peek :: Ptr Word64 -> IO Word64

poke :: Ptr Word64 -> Word64 -> IO ()

PrintfArg Word64

Methods

formatArg :: Word64 -> FieldFormatter

parseFormat :: Word64 -> ModifierParser

byte swapping

byteSwap16 :: Word16 -> Word16

Swap bytes in Word16.

Since: 4.7.0.0

byteSwap32 :: Word32 -> Word32

Reverse order of bytes in Word32.

Since: 4.7.0.0

byteSwap64 :: Word64 -> Word64

Reverse order of bytes in Word64.

Since: 4.7.0.0

Notes

• All arithmetic is performed modulo 2^n, where n is the number of bits in the type. One non-obvious consequence of this is that negate should not raise an error on negative arguments.
• For coercing between any two integer types, use fromIntegral, which is specialized for all the common cases so should be fast enough. Coercing word types to and from integer types preserves representation, not sign.
• An unbounded size unsigned integer type is available with Natural.
• The rules that hold for Enum instances over a bounded type such as Int (see the section of the Haskell report dealing with arithmetic sequences) also hold for the Enum instances over the various Word types defined here.
• Right and left shifts by amounts greater than or equal to the width of the type result in a zero result. This is contrary to the behaviour in C, which is undefined; a common interpretation is to truncate the shift count to the width of the type, for example 1 << 32 == 1 in some C implementations.