data-dword-0.3.1.1: Stick two binary words together to get a bigger one

Safe HaskellNone
LanguageHaskell2010

Data.DoubleWord

Description

This module provides strict (low and high halves are unpacked) signed and unsigned binary word data types of sizes 96, 128, 160, 192, 224, and 256 bits.

Synopsis

Documentation

class BinaryWord w => DoubleWord w where #

Defines a particular way to split a binary word in halves.

Minimal complete definition

loWord, hiWord, fromHiAndLo, extendLo, signExtendLo

Associated Types

type LoWord w #

The low half type

type HiWord w #

The high half type

Methods

loWord :: w -> LoWord w #

The low half of the word

hiWord :: w -> HiWord w #

The high half of the word

fromHiAndLo :: HiWord w -> LoWord w -> w #

Construct a word from the low and high halves

extendLo :: LoWord w -> w #

Extend the low half

signExtendLo :: SignedWord (LoWord w) -> w #

Sign-extend the low half

Instances

DoubleWord Int16 # 
DoubleWord Int32 # 
DoubleWord Int64 # 
DoubleWord Word16 # 
DoubleWord Word32 # 
DoubleWord Word64 # 
DoubleWord Int96 # 
DoubleWord Word96 # 
DoubleWord Int128 # 
DoubleWord Word128 # 
DoubleWord Int160 # 
DoubleWord Word160 # 
DoubleWord Int192 # 
DoubleWord Word192 # 
DoubleWord Int224 # 
DoubleWord Word224 # 
DoubleWord Int256 # 
DoubleWord Word256 # 

data Word96 #

Constructors

Word96 !Word32 !Word64 

Instances

Bounded Word96 # 
Enum Word96 # 
Eq Word96 # 

Methods

(==) :: Word96 -> Word96 -> Bool #

(/=) :: Word96 -> Word96 -> Bool #

Integral Word96 # 
Data Word96 # 

Methods

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

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

toConstr :: Word96 -> Constr #

dataTypeOf :: Word96 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word96 -> Word96 #

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

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

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

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

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

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

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

Num Word96 # 
Ord Word96 # 
Read Word96 # 
Real Word96 # 
Show Word96 # 
Ix Word96 # 
Generic Word96 # 

Associated Types

type Rep Word96 :: * -> * #

Methods

from :: Word96 -> Rep Word96 x #

to :: Rep Word96 x -> Word96 #

Bits Word96 # 
FiniteBits Word96 # 
BinaryWord Word96 # 
Hashable Word96 # 

Methods

hashWithSalt :: Int -> Word96 -> Int #

hash :: Word96 -> Int #

DoubleWord Word96 # 
type Rep Word96 # 
type Rep Word96 = D1 (MetaData "Word96" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word96" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Word96 # 
type UnsignedWord Word96 # 
type LoWord Word96 # 
type HiWord Word96 # 

data Word128 #

Constructors

Word128 !Word64 !Word64 

Instances

Bounded Word128 # 
Enum Word128 # 
Eq Word128 # 

Methods

(==) :: Word128 -> Word128 -> Bool #

(/=) :: Word128 -> Word128 -> Bool #

Integral Word128 # 
Data Word128 # 

Methods

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

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

toConstr :: Word128 -> Constr #

dataTypeOf :: Word128 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word128 -> Word128 #

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

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

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

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

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

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

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

Num Word128 # 
Ord Word128 # 
Read Word128 # 
Real Word128 # 
Show Word128 # 
Ix Word128 # 
Generic Word128 # 

Associated Types

type Rep Word128 :: * -> * #

Methods

from :: Word128 -> Rep Word128 x #

to :: Rep Word128 x -> Word128 #

Bits Word128 # 
FiniteBits Word128 # 
BinaryWord Word128 # 
Hashable Word128 # 

Methods

hashWithSalt :: Int -> Word128 -> Int #

hash :: Word128 -> Int #

DoubleWord Word128 # 
type Rep Word128 # 
type Rep Word128 = D1 (MetaData "Word128" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word128" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Word128 # 
type UnsignedWord Word128 # 
type LoWord Word128 # 
type HiWord Word128 # 

data Word160 #

Constructors

Word160 !Word32 !Word128 

Instances

Bounded Word160 # 
Enum Word160 # 
Eq Word160 # 

Methods

(==) :: Word160 -> Word160 -> Bool #

(/=) :: Word160 -> Word160 -> Bool #

Integral Word160 # 
Data Word160 # 

Methods

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

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

toConstr :: Word160 -> Constr #

dataTypeOf :: Word160 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word160 -> Word160 #

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

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

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

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

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

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

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

Num Word160 # 
Ord Word160 # 
Read Word160 # 
Real Word160 # 
Show Word160 # 
Ix Word160 # 
Generic Word160 # 

Associated Types

type Rep Word160 :: * -> * #

Methods

from :: Word160 -> Rep Word160 x #

to :: Rep Word160 x -> Word160 #

Bits Word160 # 
FiniteBits Word160 # 
BinaryWord Word160 # 
Hashable Word160 # 

Methods

hashWithSalt :: Int -> Word160 -> Int #

hash :: Word160 -> Int #

DoubleWord Word160 # 
type Rep Word160 # 
type Rep Word160 = D1 (MetaData "Word160" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word160" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word160 # 
type UnsignedWord Word160 # 
type LoWord Word160 # 
type HiWord Word160 # 

data Word192 #

Constructors

Word192 !Word64 !Word128 

Instances

Bounded Word192 # 
Enum Word192 # 
Eq Word192 # 

Methods

(==) :: Word192 -> Word192 -> Bool #

(/=) :: Word192 -> Word192 -> Bool #

Integral Word192 # 
Data Word192 # 

Methods

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

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

toConstr :: Word192 -> Constr #

dataTypeOf :: Word192 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word192 -> Word192 #

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

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

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

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

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

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

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

Num Word192 # 
Ord Word192 # 
Read Word192 # 
Real Word192 # 
Show Word192 # 
Ix Word192 # 
Generic Word192 # 

Associated Types

type Rep Word192 :: * -> * #

Methods

from :: Word192 -> Rep Word192 x #

to :: Rep Word192 x -> Word192 #

Bits Word192 # 
FiniteBits Word192 # 
BinaryWord Word192 # 
Hashable Word192 # 

Methods

hashWithSalt :: Int -> Word192 -> Int #

hash :: Word192 -> Int #

DoubleWord Word192 # 
type Rep Word192 # 
type Rep Word192 = D1 (MetaData "Word192" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word192" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word192 # 
type UnsignedWord Word192 # 
type LoWord Word192 # 
type HiWord Word192 # 

data Word224 #

Constructors

Word224 !Word96 !Word128 

Instances

Bounded Word224 # 
Enum Word224 # 
Eq Word224 # 

Methods

(==) :: Word224 -> Word224 -> Bool #

(/=) :: Word224 -> Word224 -> Bool #

Integral Word224 # 
Data Word224 # 

Methods

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

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

toConstr :: Word224 -> Constr #

dataTypeOf :: Word224 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word224 -> Word224 #

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

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

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

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

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

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

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

Num Word224 # 
Ord Word224 # 
Read Word224 # 
Real Word224 # 
Show Word224 # 
Ix Word224 # 
Generic Word224 # 

Associated Types

type Rep Word224 :: * -> * #

Methods

from :: Word224 -> Rep Word224 x #

to :: Rep Word224 x -> Word224 #

Bits Word224 # 
FiniteBits Word224 # 
BinaryWord Word224 # 
Hashable Word224 # 

Methods

hashWithSalt :: Int -> Word224 -> Int #

hash :: Word224 -> Int #

DoubleWord Word224 # 
type Rep Word224 # 
type Rep Word224 = D1 (MetaData "Word224" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word224" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word96)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word224 # 
type UnsignedWord Word224 # 
type LoWord Word224 # 
type HiWord Word224 # 

data Word256 #

Constructors

Word256 !Word128 !Word128 

Instances

Bounded Word256 # 
Enum Word256 # 
Eq Word256 # 

Methods

(==) :: Word256 -> Word256 -> Bool #

(/=) :: Word256 -> Word256 -> Bool #

Integral Word256 # 
Data Word256 # 

Methods

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

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

toConstr :: Word256 -> Constr #

dataTypeOf :: Word256 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Word256 -> Word256 #

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

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

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

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

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

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

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

Num Word256 # 
Ord Word256 # 
Read Word256 # 
Real Word256 # 
Show Word256 # 
Ix Word256 # 
Generic Word256 # 

Associated Types

type Rep Word256 :: * -> * #

Methods

from :: Word256 -> Rep Word256 x #

to :: Rep Word256 x -> Word256 #

Bits Word256 # 
FiniteBits Word256 # 
BinaryWord Word256 # 
Hashable Word256 # 

Methods

hashWithSalt :: Int -> Word256 -> Int #

hash :: Word256 -> Int #

DoubleWord Word256 # 
type Rep Word256 # 
type Rep Word256 = D1 (MetaData "Word256" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Word256" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word256 # 
type UnsignedWord Word256 # 
type LoWord Word256 # 
type HiWord Word256 # 

data Int96 #

Constructors

Int96 !Int32 !Word64 

Instances

Bounded Int96 # 
Enum Int96 # 
Eq Int96 # 

Methods

(==) :: Int96 -> Int96 -> Bool #

(/=) :: Int96 -> Int96 -> Bool #

Integral Int96 # 
Data Int96 # 

Methods

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

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

toConstr :: Int96 -> Constr #

dataTypeOf :: Int96 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int96 -> Int96 #

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

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

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

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

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

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

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

Num Int96 # 
Ord Int96 # 

Methods

compare :: Int96 -> Int96 -> Ordering #

(<) :: Int96 -> Int96 -> Bool #

(<=) :: Int96 -> Int96 -> Bool #

(>) :: Int96 -> Int96 -> Bool #

(>=) :: Int96 -> Int96 -> Bool #

max :: Int96 -> Int96 -> Int96 #

min :: Int96 -> Int96 -> Int96 #

Read Int96 # 
Real Int96 # 

Methods

toRational :: Int96 -> Rational #

Show Int96 # 

Methods

showsPrec :: Int -> Int96 -> ShowS #

show :: Int96 -> String #

showList :: [Int96] -> ShowS #

Ix Int96 # 
Generic Int96 # 

Associated Types

type Rep Int96 :: * -> * #

Methods

from :: Int96 -> Rep Int96 x #

to :: Rep Int96 x -> Int96 #

Bits Int96 # 
FiniteBits Int96 # 
BinaryWord Int96 # 
Hashable Int96 # 

Methods

hashWithSalt :: Int -> Int96 -> Int #

hash :: Int96 -> Int #

DoubleWord Int96 # 
type Rep Int96 # 
type Rep Int96 = D1 (MetaData "Int96" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int96" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Int96 # 
type UnsignedWord Int96 # 
type LoWord Int96 # 
type HiWord Int96 # 

data Int128 #

Constructors

Int128 !Int64 !Word64 

Instances

Bounded Int128 # 
Enum Int128 # 
Eq Int128 # 

Methods

(==) :: Int128 -> Int128 -> Bool #

(/=) :: Int128 -> Int128 -> Bool #

Integral Int128 # 
Data Int128 # 

Methods

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

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

toConstr :: Int128 -> Constr #

dataTypeOf :: Int128 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int128 -> Int128 #

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

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

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

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

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

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

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

Num Int128 # 
Ord Int128 # 
Read Int128 # 
Real Int128 # 
Show Int128 # 
Ix Int128 # 
Generic Int128 # 

Associated Types

type Rep Int128 :: * -> * #

Methods

from :: Int128 -> Rep Int128 x #

to :: Rep Int128 x -> Int128 #

Bits Int128 # 
FiniteBits Int128 # 
BinaryWord Int128 # 
Hashable Int128 # 

Methods

hashWithSalt :: Int -> Int128 -> Int #

hash :: Int128 -> Int #

DoubleWord Int128 # 
type Rep Int128 # 
type Rep Int128 = D1 (MetaData "Int128" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int128" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Int128 # 
type UnsignedWord Int128 # 
type LoWord Int128 # 
type HiWord Int128 # 

data Int160 #

Constructors

Int160 !Int32 !Word128 

Instances

Bounded Int160 # 
Enum Int160 # 
Eq Int160 # 

Methods

(==) :: Int160 -> Int160 -> Bool #

(/=) :: Int160 -> Int160 -> Bool #

Integral Int160 # 
Data Int160 # 

Methods

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

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

toConstr :: Int160 -> Constr #

dataTypeOf :: Int160 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int160 -> Int160 #

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

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

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

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

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

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

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

Num Int160 # 
Ord Int160 # 
Read Int160 # 
Real Int160 # 
Show Int160 # 
Ix Int160 # 
Generic Int160 # 

Associated Types

type Rep Int160 :: * -> * #

Methods

from :: Int160 -> Rep Int160 x #

to :: Rep Int160 x -> Int160 #

Bits Int160 # 
FiniteBits Int160 # 
BinaryWord Int160 # 
Hashable Int160 # 

Methods

hashWithSalt :: Int -> Int160 -> Int #

hash :: Int160 -> Int #

DoubleWord Int160 # 
type Rep Int160 # 
type Rep Int160 = D1 (MetaData "Int160" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int160" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int160 # 
type UnsignedWord Int160 # 
type LoWord Int160 # 
type HiWord Int160 # 

data Int192 #

Constructors

Int192 !Int64 !Word128 

Instances

Bounded Int192 # 
Enum Int192 # 
Eq Int192 # 

Methods

(==) :: Int192 -> Int192 -> Bool #

(/=) :: Int192 -> Int192 -> Bool #

Integral Int192 # 
Data Int192 # 

Methods

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

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

toConstr :: Int192 -> Constr #

dataTypeOf :: Int192 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int192 -> Int192 #

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

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

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

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

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

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

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

Num Int192 # 
Ord Int192 # 
Read Int192 # 
Real Int192 # 
Show Int192 # 
Ix Int192 # 
Generic Int192 # 

Associated Types

type Rep Int192 :: * -> * #

Methods

from :: Int192 -> Rep Int192 x #

to :: Rep Int192 x -> Int192 #

Bits Int192 # 
FiniteBits Int192 # 
BinaryWord Int192 # 
Hashable Int192 # 

Methods

hashWithSalt :: Int -> Int192 -> Int #

hash :: Int192 -> Int #

DoubleWord Int192 # 
type Rep Int192 # 
type Rep Int192 = D1 (MetaData "Int192" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int192" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int192 # 
type UnsignedWord Int192 # 
type LoWord Int192 # 
type HiWord Int192 # 

data Int224 #

Constructors

Int224 !Int96 !Word128 

Instances

Bounded Int224 # 
Enum Int224 # 
Eq Int224 # 

Methods

(==) :: Int224 -> Int224 -> Bool #

(/=) :: Int224 -> Int224 -> Bool #

Integral Int224 # 
Data Int224 # 

Methods

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

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

toConstr :: Int224 -> Constr #

dataTypeOf :: Int224 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int224 -> Int224 #

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

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

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

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

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

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

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

Num Int224 # 
Ord Int224 # 
Read Int224 # 
Real Int224 # 
Show Int224 # 
Ix Int224 # 
Generic Int224 # 

Associated Types

type Rep Int224 :: * -> * #

Methods

from :: Int224 -> Rep Int224 x #

to :: Rep Int224 x -> Int224 #

Bits Int224 # 
FiniteBits Int224 # 
BinaryWord Int224 # 
Hashable Int224 # 

Methods

hashWithSalt :: Int -> Int224 -> Int #

hash :: Int224 -> Int #

DoubleWord Int224 # 
type Rep Int224 # 
type Rep Int224 = D1 (MetaData "Int224" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int224" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int96)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int224 # 
type UnsignedWord Int224 # 
type LoWord Int224 # 
type HiWord Int224 # 

data Int256 #

Constructors

Int256 !Int128 !Word128 

Instances

Bounded Int256 # 
Enum Int256 # 
Eq Int256 # 

Methods

(==) :: Int256 -> Int256 -> Bool #

(/=) :: Int256 -> Int256 -> Bool #

Integral Int256 # 
Data Int256 # 

Methods

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

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

toConstr :: Int256 -> Constr #

dataTypeOf :: Int256 -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Int256 -> Int256 #

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

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

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

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

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

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

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

Num Int256 # 
Ord Int256 # 
Read Int256 # 
Real Int256 # 
Show Int256 # 
Ix Int256 # 
Generic Int256 # 

Associated Types

type Rep Int256 :: * -> * #

Methods

from :: Int256 -> Rep Int256 x #

to :: Rep Int256 x -> Int256 #

Bits Int256 # 
FiniteBits Int256 # 
BinaryWord Int256 # 
Hashable Int256 # 

Methods

hashWithSalt :: Int -> Int256 -> Int #

hash :: Int256 -> Int #

DoubleWord Int256 # 
type Rep Int256 # 
type Rep Int256 = D1 (MetaData "Int256" "Data.DoubleWord" "data-dword-0.3.1.1-GGOKQB0aFR8D0mMGLnYXAF" False) (C1 (MetaCons "Int256" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int128)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int256 # 
type UnsignedWord Int256 # 
type LoWord Int256 # 
type HiWord Int256 #