Relude.Numeric

Provides numerical data types and functions.

Since: 0.5.0

Reexports

xor :: Bits a => a -> a -> a infixl 6

Bitwise "xor"

toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b

Attempt to convert an Integral type a to an Integral type b using the size of the types as measured by Bits methods.

A simpler version of this function is:

toIntegral :: (Integral a, Integral b) => a -> Maybe b
toIntegral x
  | toInteger x == toInteger y = Just y
  | otherwise                  = Nothing
  where
    y = fromIntegral x

This version requires going through Integer, which can be inefficient. However, toIntegralSized is optimized to allow GHC to statically determine the relative type sizes (as measured by bitSizeMaybe and isSigned) and avoid going through Integer for many types. (The implementation uses fromIntegral, which is itself optimized with rules for base types but may go through Integer for some type pairs.)

@since base-4.8.0.0

module Data.Int

data Word8

8-bit unsigned integer type

Instances

PrintfArg Word8

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

NFData Word8

Defined in Control.DeepSeq

Methods

rnf :: Word8 -> ()

Bits Word8

@since base-2.01

Defined in GHC.Internal.Word

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

FiniteBits Word8

@since base-4.6.0.0

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

Data Word8

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

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 :: forall r r'. (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

Bounded Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

@since base-2.01

Defined in GHC.Internal.Word

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]

Ix Word8

@since base-2.01

Defined in GHC.Internal.Word

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

Num Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Read Word8

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Integral Word8

@since base-2.01

Defined in GHC.Internal.Word

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

Real Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word8 -> Rational

Show Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Eq Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

Ord Word8

@since base-2.01

Defined in GHC.Internal.Word

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

Hashable Word8

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Lift Word8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word8 -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Word8 -> Code m Word8

data Word

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

Instances

PrintfArg Word

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

NFData Word

Defined in Control.DeepSeq

Methods

rnf :: Word -> ()

Bits Word

@since base-2.01

Defined in GHC.Internal.Bits

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

FiniteBits Word

@since base-4.6.0.0

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

Data Word

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

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 :: forall r r'. (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

Bounded Word

@since base-2.01

Defined in GHC.Internal.Enum

Methods

minBound :: Word

maxBound :: Word

Enum Word

@since base-2.01

Defined in GHC.Internal.Enum

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]

Num Word

@since base-2.01

Defined in GHC.Internal.Num

Methods

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

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

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

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Read Word

@since base-4.5.0.0

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Integral Word

@since base-2.01

Defined in GHC.Internal.Real

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

Real Word

@since base-2.01

Defined in GHC.Internal.Real

Methods

toRational :: Word -> Rational

Show Word

@since base-2.01

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Eq Word

Defined in GHC.Classes

Methods

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

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

Ord Word

Defined in GHC.Classes

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

Hashable Word

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word -> Int

hash :: Word -> Int

Lift Word

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Word -> Code m Word

Generic1 (URec Word :: k -> Type)

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec Word :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))

Methods

from1 :: forall (a :: k). URec Word a -> Rep1 (URec Word :: k -> Type) a

to1 :: forall (a :: k). Rep1 (URec Word :: k -> Type) a -> URec Word a

Foldable (UWord :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UWord m -> m

foldMap :: Monoid m => (a -> m) -> UWord a -> m

foldMap' :: Monoid m => (a -> m) -> UWord a -> m

foldr :: (a -> b -> b) -> b -> UWord a -> b

foldr' :: (a -> b -> b) -> b -> UWord a -> b

foldl :: (b -> a -> b) -> b -> UWord a -> b

foldl' :: (b -> a -> b) -> b -> UWord a -> b

foldr1 :: (a -> a -> a) -> UWord a -> a

foldl1 :: (a -> a -> a) -> UWord a -> a

toList :: UWord a -> [a]

null :: UWord a -> Bool

length :: UWord a -> Int

elem :: Eq a => a -> UWord a -> Bool

maximum :: Ord a => UWord a -> a

minimum :: Ord a => UWord a -> a

sum :: Num a => UWord a -> a

product :: Num a => UWord a -> a

Traversable (UWord :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b)

sequenceA :: Applicative f => UWord (f a) -> f (UWord a)

mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b)

sequence :: Monad m => UWord (m a) -> m (UWord a)

Functor (URec Word :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

Generic (URec Word p)

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec Word p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

Methods

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

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

Show (URec Word p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Eq (URec Word p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

Ord (URec Word p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

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

data URec Word (p :: k)

Used for marking occurrences of Word#

@since base-4.9.0.0

Defined in GHC.Internal.Generics

data URec Word (p :: k) = UWord {

• uWord# :: Word#

}

type Rep1 (URec Word :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))

type Rep (URec Word p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

data Word64

64-bit unsigned integer type

Instances

PrintfArg Word64

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word64 -> FieldFormatter

parseFormat :: Word64 -> ModifierParser

NFData Word64

Defined in Control.DeepSeq

Methods

rnf :: Word64 -> ()

Bits Word64

@since base-2.01

Defined in GHC.Internal.Word

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

FiniteBits Word64

@since base-4.6.0.0

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

Data Word64

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

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 :: forall r r'. (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

Bounded Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

minBound :: Word64

maxBound :: Word64

Enum Word64

@since base-2.01

Defined in GHC.Internal.Word

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]

Ix Word64

@since base-2.01

Defined in GHC.Internal.Word

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

Num Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Read Word64

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Integral Word64

@since base-2.01

Defined in GHC.Internal.Word

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

Real Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word64 -> Rational

Show Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Eq Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

Ord Word64

@since base-2.01

Defined in GHC.Internal.Word

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

Hashable Word64

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word64 -> Int

hash :: Word64 -> Int

Lift Word64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word64 -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Word64 -> Code m Word64

data Word32

32-bit unsigned integer type

Instances

PrintfArg Word32

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word32 -> FieldFormatter

parseFormat :: Word32 -> ModifierParser

NFData Word32

Defined in Control.DeepSeq

Methods

rnf :: Word32 -> ()

Bits Word32

@since base-2.01

Defined in GHC.Internal.Word

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

FiniteBits Word32

@since base-4.6.0.0

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

Data Word32

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

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 :: forall r r'. (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

Bounded Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

minBound :: Word32

maxBound :: Word32

Enum Word32

@since base-2.01

Defined in GHC.Internal.Word

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]

Ix Word32

@since base-2.01

Defined in GHC.Internal.Word

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

Num Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Read Word32

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Integral Word32

@since base-2.01

Defined in GHC.Internal.Word

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

Real Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word32 -> Rational

Show Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Eq Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

Ord Word32

@since base-2.01

Defined in GHC.Internal.Word

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

Hashable Word32

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word32 -> Int

hash :: Word32 -> Int

Lift Word32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word32 -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Word32 -> Code m Word32

data Word16

16-bit unsigned integer type

Instances

PrintfArg Word16

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word16 -> FieldFormatter

parseFormat :: Word16 -> ModifierParser

NFData Word16

Defined in Control.DeepSeq

Methods

rnf :: Word16 -> ()

Bits Word16

@since base-2.01

Defined in GHC.Internal.Word

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

FiniteBits Word16

@since base-4.6.0.0

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

Data Word16

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

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 :: forall r r'. (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

Bounded Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

minBound :: Word16

maxBound :: Word16

Enum Word16

@since base-2.01

Defined in GHC.Internal.Word

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]

Ix Word16

@since base-2.01

Defined in GHC.Internal.Word

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

Num Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Read Word16

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Integral Word16

@since base-2.01

Defined in GHC.Internal.Word

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

Real Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word16 -> Rational

Show Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Eq Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

Ord Word16

@since base-2.01

Defined in GHC.Internal.Word

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

Hashable Word16

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word16 -> Int

hash :: Word16 -> Int

Lift Word16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Word16 -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Word16 -> Code m Word16

byteSwap16 :: Word16 -> Word16

Reverse order of bytes in Word16.

@since base-4.7.0.0

byteSwap32 :: Word32 -> Word32

Reverse order of bytes in Word32.

@since base-4.7.0.0

byteSwap64 :: Word64 -> Word64

Reverse order of bytes in Word64.

@since base-4.7.0.0

minInt :: Int

maxInt :: Int

data Float

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Constructors

F# Float#

Instances

PrintfArg Float

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

NFData Float

Defined in Control.DeepSeq

Methods

rnf :: Float -> ()

Data Float

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

Methods

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

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

toConstr :: Float -> Constr

dataTypeOf :: Float -> DataType

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

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

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

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

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

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

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

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

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

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

Floating Float

@since base-2.01

Defined in GHC.Internal.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

RealFloat Float

@since base-2.01

Defined in GHC.Internal.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Read Float

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

Eq Float

Note that due to the presence of NaN, Float's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Float)
False

Also note that Float's Eq instance does not satisfy extensionality:

>>> 0 == (-0 :: Float)
True
>>> recip 0 == recip (-0 :: Float)
False

Defined in GHC.Classes

Methods

(==) :: Float -> Float -> Bool

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

Ord Float

See instance Ord Double for discussion of deviations from IEEE 754 standard.

Defined in GHC.Classes

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

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

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Hashable Float

Note: prior to hashable-1.3.0.0, hash 0.0 /= hash (-0.0)

The hash of NaN is not well defined.

Since: hashable-1.3.0.0

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Float -> Int

hash :: Float -> Int

Lift Float

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Float -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float

Generic1 (URec Float :: k -> Type)

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec Float :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

Methods

from1 :: forall (a :: k). URec Float a -> Rep1 (URec Float :: k -> Type) a

to1 :: forall (a :: k). Rep1 (URec Float :: k -> Type) a -> URec Float a

Foldable (UFloat :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UFloat m -> m

foldMap :: Monoid m => (a -> m) -> UFloat a -> m

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m

foldr :: (a -> b -> b) -> b -> UFloat a -> b

foldr' :: (a -> b -> b) -> b -> UFloat a -> b

foldl :: (b -> a -> b) -> b -> UFloat a -> b

foldl' :: (b -> a -> b) -> b -> UFloat a -> b

foldr1 :: (a -> a -> a) -> UFloat a -> a

foldl1 :: (a -> a -> a) -> UFloat a -> a

toList :: UFloat a -> [a]

null :: UFloat a -> Bool

length :: UFloat a -> Int

elem :: Eq a => a -> UFloat a -> Bool

maximum :: Ord a => UFloat a -> a

minimum :: Ord a => UFloat a -> a

sum :: Num a => UFloat a -> a

product :: Num a => UFloat a -> a

Traversable (UFloat :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b)

sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a)

mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b)

sequence :: Monad m => UFloat (m a) -> m (UFloat a)

Functor (URec Float :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

Generic (URec Float p)

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec Float p)

Defined in GHC.Internal.Generics

type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

Methods

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

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

Show (URec Float p)

Defined in GHC.Internal.Generics

Methods

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

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Eq (URec Float p)

Defined in GHC.Internal.Generics

Methods

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

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

Ord (URec Float p)

Defined in GHC.Internal.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering

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

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

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

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

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

data URec Float (p :: k)

Used for marking occurrences of Float#

@since base-4.9.0.0

Defined in GHC.Internal.Generics

data URec Float (p :: k) = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

type Rep (URec Float p)

Defined in GHC.Internal.Generics

type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Constructors

D# Double#

Instances

PrintfArg Double

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

NFData Double

Defined in Control.DeepSeq

Methods

rnf :: Double -> ()

Data Double

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

Methods

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

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

toConstr :: Double -> Constr

dataTypeOf :: Double -> DataType

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

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

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

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

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

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

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

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

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

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

Floating Double

@since base-2.01

Defined in GHC.Internal.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

RealFloat Double

@since base-2.01

Defined in GHC.Internal.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Read Double

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

Eq Double

Note that due to the presence of NaN, Double's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Double)
False

Also note that Double's Eq instance does not satisfy substitutivity:

>>> 0 == (-0 :: Double)
True
>>> recip 0 == recip (-0 :: Double)
False

Defined in GHC.Classes

Methods

(==) :: Double -> Double -> Bool

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

Ord Double

IEEE 754 Double-precision type includes not only numbers, but also positive and negative infinities and a special element called NaN (which can be quiet or signal).

IEEE 754-2008, section 5.11 requires that if at least one of arguments of <=, <, >, >= is NaN then the result of the comparison is False, and instance Ord Double complies with this requirement. This violates the reflexivity: both NaN <= NaN and NaN >= NaN are False.

IEEE 754-2008, section 5.10 defines totalOrder predicate. Unfortunately, compare on Doubles violates the IEEE standard and does not define a total order. More specifically, both compare NaN x and compare x NaN always return GT.

Thus, users must be extremely cautious when using instance Ord Double. For instance, one should avoid ordered containers with keys represented by Double, because data loss and corruption may happen. An IEEE-compliant compare is available in fp-ieee package as TotallyOrdered newtype.

Moving further, the behaviour of min and max with regards to NaN is also non-compliant. IEEE 754-2008, section 5.3.1 defines that quiet NaN should be treated as a missing data by minNum and maxNum functions, for example, minNum(NaN, 1) = minNum(1, NaN) = 1. Some languages such as Java deviate from the standard implementing minNum(NaN, 1) = minNum(1, NaN) = NaN. However, min / max in base are even worse: min NaN 1 is 1, but min 1 NaN is NaN.

IEEE 754-2008 compliant min / max can be found in ieee754 package under minNum / maxNum names. Implementations compliant with minimumNumber / maximumNumber from a newer IEEE 754-2019, section 9.6 are available from fp-ieee package.

Defined in GHC.Classes

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

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

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Hashable Double

Note: prior to hashable-1.3.0.0, hash 0.0 /= hash (-0.0)

The hash of NaN is not well defined.

Since: hashable-1.3.0.0

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Double -> Int

hash :: Double -> Int

Lift Double

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Double -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double

Generic1 (URec Double :: k -> Type)

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec Double :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

Methods

from1 :: forall (a :: k). URec Double a -> Rep1 (URec Double :: k -> Type) a

to1 :: forall (a :: k). Rep1 (URec Double :: k -> Type) a -> URec Double a

Foldable (UDouble :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UDouble m -> m

foldMap :: Monoid m => (a -> m) -> UDouble a -> m

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m

foldr :: (a -> b -> b) -> b -> UDouble a -> b

foldr' :: (a -> b -> b) -> b -> UDouble a -> b

foldl :: (b -> a -> b) -> b -> UDouble a -> b

foldl' :: (b -> a -> b) -> b -> UDouble a -> b

foldr1 :: (a -> a -> a) -> UDouble a -> a

foldl1 :: (a -> a -> a) -> UDouble a -> a

toList :: UDouble a -> [a]

null :: UDouble a -> Bool

length :: UDouble a -> Int

elem :: Eq a => a -> UDouble a -> Bool

maximum :: Ord a => UDouble a -> a

minimum :: Ord a => UDouble a -> a

sum :: Num a => UDouble a -> a

product :: Num a => UDouble a -> a

Traversable (UDouble :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b)

sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a)

mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b)

sequence :: Monad m => UDouble (m a) -> m (UDouble a)

Functor (URec Double :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

Generic (URec Double p)

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec Double p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

Methods

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

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

Show (URec Double p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Eq (URec Double p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

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

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

Ord (URec Double p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering

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

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

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

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

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

data URec Double (p :: k)

Used for marking occurrences of Double#

@since base-4.9.0.0

Defined in GHC.Internal.Generics

data URec Double (p :: k) = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double :: k -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

type Rep (URec Double p)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

class Fractional a => Floating a where

Trigonometric and hyperbolic functions and related functions.

The Haskell Report defines no laws for Floating. However, (+), (*) and exp are customarily expected to define an exponential field and have the following properties:

• exp (a + b) = exp a * exp b
• exp (fromInteger 0) = fromInteger 1

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a

exp :: a -> a

sqrt :: a -> a

(**) :: a -> a -> a infixr 8

logBase :: a -> a -> a

sin :: a -> a

cos :: a -> a

tan :: a -> a

asin :: a -> a

acos :: a -> a

atan :: a -> a

sinh :: a -> a

cosh :: a -> a

tanh :: a -> a

asinh :: a -> a

acosh :: a -> a

atanh :: a -> a

Instances

Floating Double

@since base-2.01

Defined in GHC.Internal.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Floating Float

@since base-2.01

Defined in GHC.Internal.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

RealFloat a => Floating (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

pi :: Complex a

exp :: Complex a -> Complex a

log :: Complex a -> Complex a

sqrt :: Complex a -> Complex a

(**) :: Complex a -> Complex a -> Complex a

logBase :: Complex a -> Complex a -> Complex a

sin :: Complex a -> Complex a

cos :: Complex a -> Complex a

tan :: Complex a -> Complex a

asin :: Complex a -> Complex a

acos :: Complex a -> Complex a

atan :: Complex a -> Complex a

sinh :: Complex a -> Complex a

cosh :: Complex a -> Complex a

tanh :: Complex a -> Complex a

asinh :: Complex a -> Complex a

acosh :: Complex a -> Complex a

atanh :: Complex a -> Complex a

log1p :: Complex a -> Complex a

expm1 :: Complex a -> Complex a

log1pexp :: Complex a -> Complex a

log1mexp :: Complex a -> Complex a

Floating a => Floating (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

pi :: Identity a

exp :: Identity a -> Identity a

log :: Identity a -> Identity a

sqrt :: Identity a -> Identity a

(**) :: Identity a -> Identity a -> Identity a

logBase :: Identity a -> Identity a -> Identity a

sin :: Identity a -> Identity a

cos :: Identity a -> Identity a

tan :: Identity a -> Identity a

asin :: Identity a -> Identity a

acos :: Identity a -> Identity a

atan :: Identity a -> Identity a

sinh :: Identity a -> Identity a

cosh :: Identity a -> Identity a

tanh :: Identity a -> Identity a

asinh :: Identity a -> Identity a

acosh :: Identity a -> Identity a

atanh :: Identity a -> Identity a

log1p :: Identity a -> Identity a

expm1 :: Identity a -> Identity a

log1pexp :: Identity a -> Identity a

log1mexp :: Identity a -> Identity a

Floating a => Floating (Down a)

@since base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

pi :: Down a

exp :: Down a -> Down a

log :: Down a -> Down a

sqrt :: Down a -> Down a

(**) :: Down a -> Down a -> Down a

logBase :: Down a -> Down a -> Down a

sin :: Down a -> Down a

cos :: Down a -> Down a

tan :: Down a -> Down a

asin :: Down a -> Down a

acos :: Down a -> Down a

atan :: Down a -> Down a

sinh :: Down a -> Down a

cosh :: Down a -> Down a

tanh :: Down a -> Down a

asinh :: Down a -> Down a

acosh :: Down a -> Down a

atanh :: Down a -> Down a

log1p :: Down a -> Down a

expm1 :: Down a -> Down a

log1pexp :: Down a -> Down a

log1mexp :: Down a -> Down a

Floating a => Floating (Op a b)

Defined in Data.Functor.Contravariant

Methods

pi :: Op a b

exp :: Op a b -> Op a b

log :: Op a b -> Op a b

sqrt :: Op a b -> Op a b

(**) :: Op a b -> Op a b -> Op a b

logBase :: Op a b -> Op a b -> Op a b

sin :: Op a b -> Op a b

cos :: Op a b -> Op a b

tan :: Op a b -> Op a b

asin :: Op a b -> Op a b

acos :: Op a b -> Op a b

atan :: Op a b -> Op a b

sinh :: Op a b -> Op a b

cosh :: Op a b -> Op a b

tanh :: Op a b -> Op a b

asinh :: Op a b -> Op a b

acosh :: Op a b -> Op a b

atanh :: Op a b -> Op a b

log1p :: Op a b -> Op a b

expm1 :: Op a b -> Op a b

log1pexp :: Op a b -> Op a b

log1mexp :: Op a b -> Op a b

Floating a => Floating (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

pi :: Const a b

exp :: Const a b -> Const a b

log :: Const a b -> Const a b

sqrt :: Const a b -> Const a b

(**) :: Const a b -> Const a b -> Const a b

logBase :: Const a b -> Const a b -> Const a b

sin :: Const a b -> Const a b

cos :: Const a b -> Const a b

tan :: Const a b -> Const a b

asin :: Const a b -> Const a b

acos :: Const a b -> Const a b

atan :: Const a b -> Const a b

sinh :: Const a b -> Const a b

cosh :: Const a b -> Const a b

tanh :: Const a b -> Const a b

asinh :: Const a b -> Const a b

acosh :: Const a b -> Const a b

atanh :: Const a b -> Const a b

log1p :: Const a b -> Const a b

expm1 :: Const a b -> Const a b

log1pexp :: Const a b -> Const a b

log1mexp :: Const a b -> Const a b

Floating (f (g a)) => Floating (Compose f g a)

Since: base-4.20.0.0

Defined in Data.Functor.Compose

Methods

pi :: Compose f g a

exp :: Compose f g a -> Compose f g a

log :: Compose f g a -> Compose f g a

sqrt :: Compose f g a -> Compose f g a

(**) :: Compose f g a -> Compose f g a -> Compose f g a

logBase :: Compose f g a -> Compose f g a -> Compose f g a

sin :: Compose f g a -> Compose f g a

cos :: Compose f g a -> Compose f g a

tan :: Compose f g a -> Compose f g a

asin :: Compose f g a -> Compose f g a

acos :: Compose f g a -> Compose f g a

atan :: Compose f g a -> Compose f g a

sinh :: Compose f g a -> Compose f g a

cosh :: Compose f g a -> Compose f g a

tanh :: Compose f g a -> Compose f g a

asinh :: Compose f g a -> Compose f g a

acosh :: Compose f g a -> Compose f g a

atanh :: Compose f g a -> Compose f g a

log1p :: Compose f g a -> Compose f g a

expm1 :: Compose f g a -> Compose f g a

log1pexp :: Compose f g a -> Compose f g a

log1mexp :: Compose f g a -> Compose f g a

class (RealFrac a, Floating a) => RealFloat a where

Efficient, machine-independent access to the components of a floating-point number.

Minimal complete definition

floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE

Methods

floatRadix :: a -> Integer

a constant function, returning the radix of the representation (often 2)

floatDigits :: a -> Int

a constant function, returning the number of digits of floatRadix in the significand

floatRange :: a -> (Int, Int)

a constant function, returning the lowest and highest values the exponent may assume

decodeFloat :: a -> (Integer, Int)

The function decodeFloat applied to a real floating-point number returns the significand expressed as an Integer and an appropriately scaled exponent (an Int). If decodeFloat x yields (m,n), then x is equal in value to m*b^^n, where b is the floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= abs m < b^d, where d is the value of floatDigits x. In particular, decodeFloat 0 = (0,0). If the type contains a negative zero, also decodeFloat (-0.0) = (0,0). The result of decodeFloat x is unspecified if either of isNaN x or isInfinite x is True.

encodeFloat :: Integer -> Int -> a

encodeFloat performs the inverse of decodeFloat in the sense that for finite x with the exception of -0.0, uncurry encodeFloat (decodeFloat x) = x. encodeFloat m n is one of the two closest representable floating-point numbers to m*b^^n (or ±Infinity if overflow occurs); usually the closer, but if m contains too many bits, the result may be rounded in the wrong direction.

isNaN :: a -> Bool

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool

True if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool

True if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool

True if the argument is an IEEE negative zero

isIEEE :: a -> Bool

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a

a version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y). atan2 y x returns a value in the range [-pi, pi]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1, with y in a type that is RealFloat, should return the same value as atan y. A default definition of atan2 is provided, but implementors can provide a more accurate implementation.

Instances

RealFloat Double

@since base-2.01

Defined in GHC.Internal.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

RealFloat Float

@since base-2.01

Defined in GHC.Internal.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

RealFloat a => RealFloat (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

floatRadix :: Identity a -> Integer

floatDigits :: Identity a -> Int

floatRange :: Identity a -> (Int, Int)

decodeFloat :: Identity a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Identity a

exponent :: Identity a -> Int

significand :: Identity a -> Identity a

scaleFloat :: Int -> Identity a -> Identity a

isNaN :: Identity a -> Bool

isInfinite :: Identity a -> Bool

isDenormalized :: Identity a -> Bool

isNegativeZero :: Identity a -> Bool

isIEEE :: Identity a -> Bool

atan2 :: Identity a -> Identity a -> Identity a

RealFloat a => RealFloat (Down a)

@since base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

floatRadix :: Down a -> Integer

floatDigits :: Down a -> Int

floatRange :: Down a -> (Int, Int)

decodeFloat :: Down a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Down a

exponent :: Down a -> Int

significand :: Down a -> Down a

scaleFloat :: Int -> Down a -> Down a

isNaN :: Down a -> Bool

isInfinite :: Down a -> Bool

isDenormalized :: Down a -> Bool

isNegativeZero :: Down a -> Bool

isIEEE :: Down a -> Bool

atan2 :: Down a -> Down a -> Down a

RealFloat a => RealFloat (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

floatRadix :: Const a b -> Integer

floatDigits :: Const a b -> Int

floatRange :: Const a b -> (Int, Int)

decodeFloat :: Const a b -> (Integer, Int)

encodeFloat :: Integer -> Int -> Const a b

exponent :: Const a b -> Int

significand :: Const a b -> Const a b

scaleFloat :: Int -> Const a b -> Const a b

isNaN :: Const a b -> Bool

isInfinite :: Const a b -> Bool

isDenormalized :: Const a b -> Bool

isNegativeZero :: Const a b -> Bool

isIEEE :: Const a b -> Bool

atan2 :: Const a b -> Const a b -> Const a b

RealFloat (f (g a)) => RealFloat (Compose f g a)

Since: base-4.20.0.0

Defined in Data.Functor.Compose

Methods

floatRadix :: Compose f g a -> Integer

floatDigits :: Compose f g a -> Int

floatRange :: Compose f g a -> (Int, Int)

decodeFloat :: Compose f g a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Compose f g a

exponent :: Compose f g a -> Int

significand :: Compose f g a -> Compose f g a

scaleFloat :: Int -> Compose f g a -> Compose f g a

isNaN :: Compose f g a -> Bool

isInfinite :: Compose f g a -> Bool

isDenormalized :: Compose f g a -> Bool

isNegativeZero :: Compose f g a -> Bool

isIEEE :: Compose f g a -> Bool

atan2 :: Compose f g a -> Compose f g a -> Compose f g a

data Integer

Arbitrary precision integers. In contrast with fixed-size integral types such as Int, the Integer type represents the entire infinite range of integers.

Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.

If the value is small (i.e., fits into an Int), the IS constructor is used. Otherwise IP and IN constructors are used to store a BigNat representing the positive or the negative value magnitude, respectively.

Invariant: IP and IN are used iff the value does not fit in IS.

Instances

PrintfArg Integer

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Integer -> FieldFormatter

parseFormat :: Integer -> ModifierParser

NFData Integer

Defined in Control.DeepSeq

Methods

rnf :: Integer -> ()

Bits Integer

@since base-2.01

Defined in GHC.Internal.Bits

Methods

(.&.) :: Integer -> Integer -> Integer

(.|.) :: Integer -> Integer -> Integer

xor :: Integer -> Integer -> Integer

complement :: Integer -> Integer

shift :: Integer -> Int -> Integer

rotate :: Integer -> Int -> Integer

zeroBits :: Integer

bit :: Int -> Integer

setBit :: Integer -> Int -> Integer

clearBit :: Integer -> Int -> Integer

complementBit :: Integer -> Int -> Integer

testBit :: Integer -> Int -> Bool

bitSizeMaybe :: Integer -> Maybe Int

bitSize :: Integer -> Int

isSigned :: Integer -> Bool

shiftL :: Integer -> Int -> Integer

unsafeShiftL :: Integer -> Int -> Integer

shiftR :: Integer -> Int -> Integer

unsafeShiftR :: Integer -> Int -> Integer

rotateL :: Integer -> Int -> Integer

rotateR :: Integer -> Int -> Integer

popCount :: Integer -> Int

Data Integer

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

Methods

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

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

toConstr :: Integer -> Constr

dataTypeOf :: Integer -> DataType

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

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

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

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

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

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

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

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

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

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

Enum Integer

@since base-2.01

Defined in GHC.Internal.Enum

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Num Integer

@since base-2.01

Defined in GHC.Internal.Num

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Read Integer

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Integer

readList :: ReadS [Integer]

readPrec :: ReadPrec Integer

readListPrec :: ReadPrec [Integer]

Integral Integer

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Real Integer

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

toRational :: Integer -> Rational

Show Integer

@since base-2.01

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Eq Integer

Defined in GHC.Num.Integer

Methods

(==) :: Integer -> Integer -> Bool

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

Ord Integer

Defined in GHC.Num.Integer

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

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

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Hashable Integer

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Integer -> Int

hash :: Integer -> Int

Lift Integer

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Integer -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer

class Num a where

Basic numeric class.

The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

Associativity of (+)

(x + y) + z = x + (y + z)

Commutativity of (+)

x + y = y + x

fromInteger 0 is the additive identity

x + fromInteger 0 = x

negate gives the additive inverse

x + negate x = fromInteger 0

Associativity of (*)

(x * y) * z = x * (y * z)

fromInteger 1 is the multiplicative identity

x * fromInteger 1 = x and fromInteger 1 * x = x

Distributivity of (*) with respect to (+)

a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Coherence with toInteger

if the type also implements Integral, then fromInteger is a left inverse for toInteger, i.e. fromInteger (toInteger i) == i

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Minimal complete definition

(+), (*), abs, signum, fromInteger, (negate | (-))

Methods

(+) :: a -> a -> a infixl 6

(-) :: a -> a -> a infixl 6

(*) :: a -> a -> a infixl 7

negate :: a -> a

Unary negation.

abs :: a -> a

Absolute value.

signum :: a -> a

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Integer -> a

Conversion from an Integer. An integer literal represents the application of the function fromInteger to the appropriate value of type Integer, so such literals have type (Num a) => a.

Instances

Num Int16

@since base-2.01

Defined in GHC.Internal.Int

Methods

(+) :: Int16 -> Int16 -> Int16

(-) :: Int16 -> Int16 -> Int16

(*) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

abs :: Int16 -> Int16

signum :: Int16 -> Int16

fromInteger :: Integer -> Int16

Num Int32

@since base-2.01

Defined in GHC.Internal.Int

Methods

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

(*) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

abs :: Int32 -> Int32

signum :: Int32 -> Int32

fromInteger :: Integer -> Int32

Num Int64

@since base-2.01

Defined in GHC.Internal.Int

Methods

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

(*) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

abs :: Int64 -> Int64

signum :: Int64 -> Int64

fromInteger :: Integer -> Int64

Num Int8

@since base-2.01

Defined in GHC.Internal.Int

Methods

(+) :: Int8 -> Int8 -> Int8

(-) :: Int8 -> Int8 -> Int8

(*) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

abs :: Int8 -> Int8

signum :: Int8 -> Int8

fromInteger :: Integer -> Int8

Num Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Num Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Num Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Num Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Num I8

Defined in Data.Text.Foreign

Methods

(+) :: I8 -> I8 -> I8

(-) :: I8 -> I8 -> I8

(*) :: I8 -> I8 -> I8

negate :: I8 -> I8

abs :: I8 -> I8

signum :: I8 -> I8

fromInteger :: Integer -> I8

Num Size

Defined in Data.Text.Internal.Fusion.Size

Methods

(+) :: Size -> Size -> Size

(-) :: Size -> Size -> Size

(*) :: Size -> Size -> Size

negate :: Size -> Size

abs :: Size -> Size

signum :: Size -> Size

fromInteger :: Integer -> Size

Num Integer

@since base-2.01

Defined in GHC.Internal.Num

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Num Natural

Note that Natural's Num instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though.

@since base-4.8.0.0

Defined in GHC.Internal.Num

Methods

(+) :: Natural -> Natural -> Natural

(-) :: Natural -> Natural -> Natural

(*) :: Natural -> Natural -> Natural

negate :: Natural -> Natural

abs :: Natural -> Natural

signum :: Natural -> Natural

fromInteger :: Integer -> Natural

Num Int

@since base-2.01

Defined in GHC.Internal.Num

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Num Word

@since base-2.01

Defined in GHC.Internal.Num

Methods

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

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

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

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

RealFloat a => Num (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a

(-) :: Complex a -> Complex a -> Complex a

(*) :: Complex a -> Complex a -> Complex a

negate :: Complex a -> Complex a

abs :: Complex a -> Complex a

signum :: Complex a -> Complex a

fromInteger :: Integer -> Complex a

Num a => Num (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(+) :: Max a -> Max a -> Max a

(-) :: Max a -> Max a -> Max a

(*) :: Max a -> Max a -> Max a

negate :: Max a -> Max a

abs :: Max a -> Max a

signum :: Max a -> Max a

fromInteger :: Integer -> Max a

Num a => Num (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(+) :: Min a -> Min a -> Min a

(-) :: Min a -> Min a -> Min a

(*) :: Min a -> Min a -> Min a

negate :: Min a -> Min a

abs :: Min a -> Min a

signum :: Min a -> Min a

fromInteger :: Integer -> Min a

Num a => Num (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

(+) :: Identity a -> Identity a -> Identity a

(-) :: Identity a -> Identity a -> Identity a

(*) :: Identity a -> Identity a -> Identity a

negate :: Identity a -> Identity a

abs :: Identity a -> Identity a

signum :: Identity a -> Identity a

fromInteger :: Integer -> Identity a

Num a => Num (Down a)

@since base-4.11.0.0

Defined in GHC.Internal.Data.Ord

Methods

(+) :: Down a -> Down a -> Down a

(-) :: Down a -> Down a -> Down a

(*) :: Down a -> Down a -> Down a

negate :: Down a -> Down a

abs :: Down a -> Down a

signum :: Down a -> Down a

fromInteger :: Integer -> Down a

Num a => Num (Product a)

@since base-4.7.0.0

Defined in GHC.Internal.Data.Semigroup.Internal

Methods

(+) :: Product a -> Product a -> Product a

(-) :: Product a -> Product a -> Product a

(*) :: Product a -> Product a -> Product a

negate :: Product a -> Product a

abs :: Product a -> Product a

signum :: Product a -> Product a

fromInteger :: Integer -> Product a

Num a => Num (Sum a)

@since base-4.7.0.0

Defined in GHC.Internal.Data.Semigroup.Internal

Methods

(+) :: Sum a -> Sum a -> Sum a

(-) :: Sum a -> Sum a -> Sum a

(*) :: Sum a -> Sum a -> Sum a

negate :: Sum a -> Sum a

abs :: Sum a -> Sum a

signum :: Sum a -> Sum a

fromInteger :: Integer -> Sum a

Integral a => Num (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

(+) :: Ratio a -> Ratio a -> Ratio a

(-) :: Ratio a -> Ratio a -> Ratio a

(*) :: Ratio a -> Ratio a -> Ratio a

negate :: Ratio a -> Ratio a

abs :: Ratio a -> Ratio a

signum :: Ratio a -> Ratio a

fromInteger :: Integer -> Ratio a

HasResolution a => Num (Fixed a)

Multiplication is not associative or distributive:

>>> (0.2 * 0.6 :: Deci) * 0.9 == 0.2 * (0.6 * 0.9)
False

>>> (0.1 + 0.1 :: Deci) * 0.5 == 0.1 * 0.5 + 0.1 * 0.5
False

Since: base-2.1

Defined in Data.Fixed

Methods

(+) :: Fixed a -> Fixed a -> Fixed a

(-) :: Fixed a -> Fixed a -> Fixed a

(*) :: Fixed a -> Fixed a -> Fixed a

negate :: Fixed a -> Fixed a

abs :: Fixed a -> Fixed a

signum :: Fixed a -> Fixed a

fromInteger :: Integer -> Fixed a

Num a => Num (Op a b)

Defined in Data.Functor.Contravariant

Methods

(+) :: Op a b -> Op a b -> Op a b

(-) :: Op a b -> Op a b -> Op a b

(*) :: Op a b -> Op a b -> Op a b

negate :: Op a b -> Op a b

abs :: Op a b -> Op a b

signum :: Op a b -> Op a b

fromInteger :: Integer -> Op a b

Num a => Num (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

(+) :: Const a b -> Const a b -> Const a b

(-) :: Const a b -> Const a b -> Const a b

(*) :: Const a b -> Const a b -> Const a b

negate :: Const a b -> Const a b

abs :: Const a b -> Const a b

signum :: Const a b -> Const a b

fromInteger :: Integer -> Const a b

(Applicative f, Num a) => Num (Ap f a)

Note that even if the underlying Num and Applicative instances are lawful, for most Applicatives, this instance will not be lawful. If you use this instance with the list Applicative, the following customary laws will not hold:

Commutativity:

>>> Ap [10,20] + Ap [1,2]
Ap {getAp = [11,12,21,22]}
>>> Ap [1,2] + Ap [10,20]
Ap {getAp = [11,21,12,22]}

Additive inverse:

>>> Ap [] + negate (Ap [])
Ap {getAp = []}
>>> fromInteger 0 :: Ap [] Int
Ap {getAp = [0]}

Distributivity:

>>> Ap [1,2] * (3 + 4)
Ap {getAp = [7,14]}
>>> (Ap [1,2] * 3) + (Ap [1,2] * 4)
Ap {getAp = [7,11,10,14]}

@since base-4.12.0.0

Defined in GHC.Internal.Data.Monoid

Methods

(+) :: Ap f a -> Ap f a -> Ap f a

(-) :: Ap f a -> Ap f a -> Ap f a

(*) :: Ap f a -> Ap f a -> Ap f a

negate :: Ap f a -> Ap f a

abs :: Ap f a -> Ap f a

signum :: Ap f a -> Ap f a

fromInteger :: Integer -> Ap f a

Num (f a) => Num (Alt f a)

@since base-4.8.0.0

Defined in GHC.Internal.Data.Semigroup.Internal

Methods

(+) :: Alt f a -> Alt f a -> Alt f a

(-) :: Alt f a -> Alt f a -> Alt f a

(*) :: Alt f a -> Alt f a -> Alt f a

negate :: Alt f a -> Alt f a

abs :: Alt f a -> Alt f a

signum :: Alt f a -> Alt f a

fromInteger :: Integer -> Alt f a

Num (f (g a)) => Num (Compose f g a)

Since: base-4.19.0.0

Defined in Data.Functor.Compose

Methods

(+) :: Compose f g a -> Compose f g a -> Compose f g a

(-) :: Compose f g a -> Compose f g a -> Compose f g a

(*) :: Compose f g a -> Compose f g a -> Compose f g a

negate :: Compose f g a -> Compose f g a

abs :: Compose f g a -> Compose f g a

signum :: Compose f g a -> Compose f g a

fromInteger :: Integer -> Compose f g a

subtract :: Num a => a -> a -> a

the same as flip (-).

Because - is treated specially in the Haskell grammar, (- e) is not a section, but an application of prefix negation. However, (subtract exp) is equivalent to the disallowed section.

class Num a => Fractional a where

Fractional numbers, supporting real division.

The Haskell Report defines no laws for Fractional. However, (+) and (*) are customarily expected to define a division ring and have the following properties:

recip gives the multiplicative inverse

x * recip x = recip x * x = fromInteger 1

Totality of toRational

toRational is total

Coherence with toRational

if the type also implements Real, then fromRational is a left inverse for toRational, i.e. fromRational (toRational i) = i

Note that it isn't customarily expected that a type instance of Fractional implement a field. However, all instances in base do.

Minimal complete definition

fromRational, (recip | (/))

Methods

(/) :: a -> a -> a infixl 7

Fractional division.

recip :: a -> a

Reciprocal fraction.

fromRational :: Rational -> a

Conversion from a Rational (that is Ratio Integer). A floating literal stands for an application of fromRational to a value of type Rational, so such literals have type (Fractional a) => a.

Instances

RealFloat a => Fractional (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

(/) :: Complex a -> Complex a -> Complex a

recip :: Complex a -> Complex a

fromRational :: Rational -> Complex a

Fractional a => Fractional (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

(/) :: Identity a -> Identity a -> Identity a

recip :: Identity a -> Identity a

fromRational :: Rational -> Identity a

Fractional a => Fractional (Down a)

@since base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

(/) :: Down a -> Down a -> Down a

recip :: Down a -> Down a

fromRational :: Rational -> Down a

Integral a => Fractional (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

(/) :: Ratio a -> Ratio a -> Ratio a

recip :: Ratio a -> Ratio a

fromRational :: Rational -> Ratio a

HasResolution a => Fractional (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

(/) :: Fixed a -> Fixed a -> Fixed a

recip :: Fixed a -> Fixed a

fromRational :: Rational -> Fixed a

Fractional a => Fractional (Op a b)

Defined in Data.Functor.Contravariant

Methods

(/) :: Op a b -> Op a b -> Op a b

recip :: Op a b -> Op a b

fromRational :: Rational -> Op a b

Fractional a => Fractional (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

(/) :: Const a b -> Const a b -> Const a b

recip :: Const a b -> Const a b

fromRational :: Rational -> Const a b

Fractional (f (g a)) => Fractional (Compose f g a)

Since: base-4.20.0.0

Defined in Data.Functor.Compose

Methods

(/) :: Compose f g a -> Compose f g a -> Compose f g a

recip :: Compose f g a -> Compose f g a

fromRational :: Rational -> Compose f g a

fromIntegral :: (Integral a, Num b) => a -> b

General coercion from Integral types.

WARNING: This function performs silent truncation if the result type is not at least as big as the argument's type.

realToFrac :: (Real a, Fractional b) => a -> b

General coercion to Fractional types.

WARNING: This function goes through the Rational type, which does not have values for NaN for example. This means it does not round-trip.

For Double it also behaves differently with or without -O0:

Prelude> realToFrac nan -- With -O0
-Infinity
Prelude> realToFrac nan
NaN

class (Real a, Enum a) => Integral a where

Integral numbers, supporting integer division.

The Haskell Report defines no laws for Integral. However, Integral instances are customarily expected to define a Euclidean domain and have the following properties for the div/mod and quot/rem pairs, given suitable Euclidean functions f and g:

• x = y * quot x y + rem x y with rem x y = fromInteger 0 or g (rem x y) < g y
• x = y * div x y + mod x y with mod x y = fromInteger 0 or f (mod x y) < f y

An example of a suitable Euclidean function, for Integer's instance, is abs.

In addition, toInteger should be total, and fromInteger should be a left inverse for it, i.e. fromInteger (toInteger i) = i.

Minimal complete definition

quotRem, toInteger

Methods

quot :: a -> a -> a infixl 7

Integer division truncated toward zero.

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

rem :: a -> a -> a infixl 7

Integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

div :: a -> a -> a infixl 7

Integer division truncated toward negative infinity.

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

mod :: a -> a -> a infixl 7

Integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

quotRem :: a -> a -> (a, a)

Simultaneous quot and rem.

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

divMod :: a -> a -> (a, a)

simultaneous div and mod.

WARNING: This function is partial (because it throws when 0 is passed as the divisor) for all the integer types in base.

toInteger :: a -> Integer

Conversion to Integer.

Instances

Integral Int16

@since base-2.01

Defined in GHC.Internal.Int

Methods

quot :: Int16 -> Int16 -> Int16

rem :: Int16 -> Int16 -> Int16

div :: Int16 -> Int16 -> Int16

mod :: Int16 -> Int16 -> Int16

quotRem :: Int16 -> Int16 -> (Int16, Int16)

divMod :: Int16 -> Int16 -> (Int16, Int16)

toInteger :: Int16 -> Integer

Integral Int32

@since base-2.01

Defined in GHC.Internal.Int

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Integral Int64

@since base-2.01

Defined in GHC.Internal.Int

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

Integral Int8

@since base-2.01

Defined in GHC.Internal.Int

Methods

quot :: Int8 -> Int8 -> Int8

rem :: Int8 -> Int8 -> Int8

div :: Int8 -> Int8 -> Int8

mod :: Int8 -> Int8 -> Int8

quotRem :: Int8 -> Int8 -> (Int8, Int8)

divMod :: Int8 -> Int8 -> (Int8, Int8)

toInteger :: Int8 -> Integer

Integral Word16

@since base-2.01

Defined in GHC.Internal.Word

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

Integral Word32

@since base-2.01

Defined in GHC.Internal.Word

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

Integral Word64

@since base-2.01

Defined in GHC.Internal.Word

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

Integral Word8

@since base-2.01

Defined in GHC.Internal.Word

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

Integral I8

Defined in Data.Text.Foreign

Methods

quot :: I8 -> I8 -> I8

rem :: I8 -> I8 -> I8

div :: I8 -> I8 -> I8

mod :: I8 -> I8 -> I8

quotRem :: I8 -> I8 -> (I8, I8)

divMod :: I8 -> I8 -> (I8, I8)

toInteger :: I8 -> Integer

Integral Integer

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Integral Natural

@since base-4.8.0.0

Defined in GHC.Internal.Real

Methods

quot :: Natural -> Natural -> Natural

rem :: Natural -> Natural -> Natural

div :: Natural -> Natural -> Natural

mod :: Natural -> Natural -> Natural

quotRem :: Natural -> Natural -> (Natural, Natural)

divMod :: Natural -> Natural -> (Natural, Natural)

toInteger :: Natural -> Integer

Integral Int

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Integral Word

@since base-2.01

Defined in GHC.Internal.Real

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

Integral a => Integral (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

quot :: Identity a -> Identity a -> Identity a

rem :: Identity a -> Identity a -> Identity a

div :: Identity a -> Identity a -> Identity a

mod :: Identity a -> Identity a -> Identity a

quotRem :: Identity a -> Identity a -> (Identity a, Identity a)

divMod :: Identity a -> Identity a -> (Identity a, Identity a)

toInteger :: Identity a -> Integer

Integral a => Integral (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

quot :: Const a b -> Const a b -> Const a b

rem :: Const a b -> Const a b -> Const a b

div :: Const a b -> Const a b -> Const a b

mod :: Const a b -> Const a b -> Const a b

quotRem :: Const a b -> Const a b -> (Const a b, Const a b)

divMod :: Const a b -> Const a b -> (Const a b, Const a b)

toInteger :: Const a b -> Integer

Integral (f (g a)) => Integral (Compose f g a)

Since: base-4.19.0.0

Defined in Data.Functor.Compose

Methods

quot :: Compose f g a -> Compose f g a -> Compose f g a

rem :: Compose f g a -> Compose f g a -> Compose f g a

div :: Compose f g a -> Compose f g a -> Compose f g a

mod :: Compose f g a -> Compose f g a -> Compose f g a

quotRem :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a)

divMod :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a)

toInteger :: Compose f g a -> Integer

class (Num a, Ord a) => Real a where

Real numbers.

The Haskell report defines no laws for Real, however Real instances are customarily expected to adhere to the following law:

Coherence with fromRational

if the type also implements Fractional, then fromRational is a left inverse for toRational, i.e. fromRational (toRational i) = i

The law does not hold for Float, Double, CFloat, CDouble, etc., because these types contain non-finite values, which cannot be roundtripped through Rational.

Methods

toRational :: a -> Rational

Rational equivalent of its real argument with full precision.

Instances

Real Int16

@since base-2.01

Defined in GHC.Internal.Int

Methods

toRational :: Int16 -> Rational

Real Int32

@since base-2.01

Defined in GHC.Internal.Int

Methods

toRational :: Int32 -> Rational

Real Int64

@since base-2.01

Defined in GHC.Internal.Int

Methods

toRational :: Int64 -> Rational

Real Int8

@since base-2.01

Defined in GHC.Internal.Int

Methods

toRational :: Int8 -> Rational

Real Word16

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word16 -> Rational

Real Word32

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word32 -> Rational

Real Word64

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word64 -> Rational

Real Word8

@since base-2.01

Defined in GHC.Internal.Word

Methods

toRational :: Word8 -> Rational

Real I8

Defined in Data.Text.Foreign

Methods

toRational :: I8 -> Rational

Real Integer

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

toRational :: Integer -> Rational

Real Natural

@since base-4.8.0.0

Defined in GHC.Internal.Real

Methods

toRational :: Natural -> Rational

Real Int

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

toRational :: Int -> Rational

Real Word

@since base-2.01

Defined in GHC.Internal.Real

Methods

toRational :: Word -> Rational

Real a => Real (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

toRational :: Identity a -> Rational

Real a => Real (Down a)

@since base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

toRational :: Down a -> Rational

Integral a => Real (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

toRational :: Ratio a -> Rational

HasResolution a => Real (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

toRational :: Fixed a -> Rational

Real a => Real (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

toRational :: Const a b -> Rational

Real (f (g a)) => Real (Compose f g a)

Since: base-4.19.0.0

Defined in Data.Functor.Compose

Methods

toRational :: Compose f g a -> Rational

class (Real a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

properFraction :: Integral b => a -> (b, a)

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

• n is an integral number with the same sign as x; and
• f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

truncate :: Integral b => a -> b

truncate x returns the integer nearest x between zero and x

round :: Integral b => a -> b

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: Integral b => a -> b

ceiling x returns the least integer not less than x

floor :: Integral b => a -> b

floor x returns the greatest integer not greater than x

Instances

RealFrac a => RealFrac (Identity a)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Identity

Methods

properFraction :: Integral b => Identity a -> (b, Identity a)

truncate :: Integral b => Identity a -> b

round :: Integral b => Identity a -> b

ceiling :: Integral b => Identity a -> b

floor :: Integral b => Identity a -> b

RealFrac a => RealFrac (Down a)

@since base-4.14.0.0

Defined in GHC.Internal.Data.Ord

Methods

properFraction :: Integral b => Down a -> (b, Down a)

truncate :: Integral b => Down a -> b

round :: Integral b => Down a -> b

ceiling :: Integral b => Down a -> b

floor :: Integral b => Down a -> b

Integral a => RealFrac (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

properFraction :: Integral b => Ratio a -> (b, Ratio a)

truncate :: Integral b => Ratio a -> b

round :: Integral b => Ratio a -> b

ceiling :: Integral b => Ratio a -> b

floor :: Integral b => Ratio a -> b

HasResolution a => RealFrac (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

properFraction :: Integral b => Fixed a -> (b, Fixed a)

truncate :: Integral b => Fixed a -> b

round :: Integral b => Fixed a -> b

ceiling :: Integral b => Fixed a -> b

floor :: Integral b => Fixed a -> b

RealFrac a => RealFrac (Const a b)

@since base-4.9.0.0

Defined in GHC.Internal.Data.Functor.Const

Methods

properFraction :: Integral b0 => Const a b -> (b0, Const a b)

truncate :: Integral b0 => Const a b -> b0

round :: Integral b0 => Const a b -> b0

ceiling :: Integral b0 => Const a b -> b0

floor :: Integral b0 => Const a b -> b0

RealFrac (f (g a)) => RealFrac (Compose f g a)

Since: base-4.20.0.0

Defined in Data.Functor.Compose

Methods

properFraction :: Integral b => Compose f g a -> (b, Compose f g a)

truncate :: Integral b => Compose f g a -> b

round :: Integral b => Compose f g a -> b

ceiling :: Integral b => Compose f g a -> b

floor :: Integral b => Compose f g a -> b

data Ratio a

Rational numbers, with numerator and denominator of some Integral type.

Note that Ratio's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural's Num instance has similar problems to Natural's.

Instances

NFData1 Ratio

Available on base >=4.9

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Ratio a -> ()

Integral a => Lift (Ratio a :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Ratio a -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Ratio a -> Code m (Ratio a)

NFData a => NFData (Ratio a)

Defined in Control.DeepSeq

Methods

rnf :: Ratio a -> ()

(Data a, Integral a) => Data (Ratio a)

@since base-4.0.0.0

Defined in GHC.Internal.Data.Data

Methods

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

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

toConstr :: Ratio a -> Constr

dataTypeOf :: Ratio a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a))

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

gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a

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

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

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

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

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

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

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

Integral a => Enum (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

succ :: Ratio a -> Ratio a

pred :: Ratio a -> Ratio a

toEnum :: Int -> Ratio a

fromEnum :: Ratio a -> Int

enumFrom :: Ratio a -> [Ratio a]

enumFromThen :: Ratio a -> Ratio a -> [Ratio a]

enumFromTo :: Ratio a -> Ratio a -> [Ratio a]

enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a]

Integral a => Num (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

(+) :: Ratio a -> Ratio a -> Ratio a

(-) :: Ratio a -> Ratio a -> Ratio a

(*) :: Ratio a -> Ratio a -> Ratio a

negate :: Ratio a -> Ratio a

abs :: Ratio a -> Ratio a

signum :: Ratio a -> Ratio a

fromInteger :: Integer -> Ratio a

(Integral a, Read a) => Read (Ratio a)

@since base-2.01

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS (Ratio a)

readList :: ReadS [Ratio a]

readPrec :: ReadPrec (Ratio a)

readListPrec :: ReadPrec [Ratio a]

Integral a => Fractional (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

(/) :: Ratio a -> Ratio a -> Ratio a

recip :: Ratio a -> Ratio a

fromRational :: Rational -> Ratio a

Integral a => Real (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

toRational :: Ratio a -> Rational

Integral a => RealFrac (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

properFraction :: Integral b => Ratio a -> (b, Ratio a)

truncate :: Integral b => Ratio a -> b

round :: Integral b => Ratio a -> b

ceiling :: Integral b => Ratio a -> b

floor :: Integral b => Ratio a -> b

Show a => Show (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

showsPrec :: Int -> Ratio a -> ShowS

show :: Ratio a -> String

showList :: [Ratio a] -> ShowS

Eq a => Eq (Ratio a)

@since base-2.01

Defined in GHC.Internal.Real

Methods

(==) :: Ratio a -> Ratio a -> Bool

(/=) :: Ratio a -> Ratio a -> Bool

Integral a => Ord (Ratio a)

@since base-2.0.1

Defined in GHC.Internal.Real

Methods

compare :: Ratio a -> Ratio a -> Ordering

(<) :: Ratio a -> Ratio a -> Bool

(<=) :: Ratio a -> Ratio a -> Bool

(>) :: Ratio a -> Ratio a -> Bool

(>=) :: Ratio a -> Ratio a -> Bool

max :: Ratio a -> Ratio a -> Ratio a

min :: Ratio a -> Ratio a -> Ratio a

Hashable a => Hashable (Ratio a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Ratio a -> Int

hash :: Ratio a -> Int

type Rational = Ratio Integer

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

(^) :: (Num a, Integral b) => a -> b -> a infixr 8

raise a number to a non-negative integral power

numerator :: Ratio a -> a

Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

denominator :: Ratio a -> a

Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

even :: Integral a => a -> Bool

odd :: Integral a => a -> Bool

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8

raise a number to an integral power

gcd :: Integral a => a -> a -> a

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

lcm :: Integral a => a -> a -> a

lcm x y is the smallest positive integer that both x and y divide.

data Natural

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Instances

PrintfArg Natural

Since: base-4.8.0.0

Defined in Text.Printf

Methods

formatArg :: Natural -> FieldFormatter

parseFormat :: Natural -> ModifierParser

NFData Natural

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: Natural -> ()

Bits Natural

@since base-4.8.0

Defined in GHC.Internal.Bits

Methods

(.&.) :: Natural -> Natural -> Natural

(.|.) :: Natural -> Natural -> Natural

xor :: Natural -> Natural -> Natural

complement :: Natural -> Natural

shift :: Natural -> Int -> Natural

rotate :: Natural -> Int -> Natural

zeroBits :: Natural

bit :: Int -> Natural

setBit :: Natural -> Int -> Natural

clearBit :: Natural -> Int -> Natural

complementBit :: Natural -> Int -> Natural

testBit :: Natural -> Int -> Bool

bitSizeMaybe :: Natural -> Maybe Int

bitSize :: Natural -> Int

isSigned :: Natural -> Bool

shiftL :: Natural -> Int -> Natural

unsafeShiftL :: Natural -> Int -> Natural

shiftR :: Natural -> Int -> Natural

unsafeShiftR :: Natural -> Int -> Natural

rotateL :: Natural -> Int -> Natural

rotateR :: Natural -> Int -> Natural

popCount :: Natural -> Int

Data Natural

@since base-4.8.0.0

Defined in GHC.Internal.Data.Data

Methods

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

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

toConstr :: Natural -> Constr

dataTypeOf :: Natural -> DataType

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

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

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

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

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

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

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

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

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

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

Enum Natural

@since base-4.8.0.0

Defined in GHC.Internal.Enum

Methods

succ :: Natural -> Natural

pred :: Natural -> Natural

toEnum :: Int -> Natural

fromEnum :: Natural -> Int

enumFrom :: Natural -> [Natural]

enumFromThen :: Natural -> Natural -> [Natural]

enumFromTo :: Natural -> Natural -> [Natural]

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]

Num Natural

Note that Natural's Num instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though.

@since base-4.8.0.0

Defined in GHC.Internal.Num

Methods

(+) :: Natural -> Natural -> Natural

(-) :: Natural -> Natural -> Natural

(*) :: Natural -> Natural -> Natural

negate :: Natural -> Natural

abs :: Natural -> Natural

signum :: Natural -> Natural

fromInteger :: Integer -> Natural

Read Natural

@since base-4.8.0.0

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Natural

readList :: ReadS [Natural]

readPrec :: ReadPrec Natural

readListPrec :: ReadPrec [Natural]

Integral Natural

@since base-4.8.0.0

Defined in GHC.Internal.Real

Methods

quot :: Natural -> Natural -> Natural

rem :: Natural -> Natural -> Natural

div :: Natural -> Natural -> Natural

mod :: Natural -> Natural -> Natural

quotRem :: Natural -> Natural -> (Natural, Natural)

divMod :: Natural -> Natural -> (Natural, Natural)

toInteger :: Natural -> Integer

Real Natural

@since base-4.8.0.0

Defined in GHC.Internal.Real

Methods

toRational :: Natural -> Rational

Show Natural

@since base-4.8.0.0

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

Eq Natural

Defined in GHC.Num.Natural

Methods

(==) :: Natural -> Natural -> Bool

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

Ord Natural

Defined in GHC.Num.Natural

Methods

compare :: Natural -> Natural -> Ordering

(<) :: Natural -> Natural -> Bool

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

(>) :: Natural -> Natural -> Bool

(>=) :: Natural -> Natural -> Bool

max :: Natural -> Natural -> Natural

min :: Natural -> Natural -> Natural

Hashable Natural

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Natural -> Int

hash :: Natural -> Int

KnownNat n => HasResolution (n :: Nat)

For example, Fixed 1000 will give you a Fixed with a resolution of 1000.

Defined in Data.Fixed

Methods

resolution :: p n -> Integer

TestCoercion SNat

@since base-4.18.0.0

Defined in GHC.Internal.TypeNats

Methods

testCoercion :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (Coercion a b)

TestEquality SNat

@since base-4.18.0.0

Defined in GHC.Internal.TypeNats

Methods

testEquality :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (a :~: b)

Lift Natural

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Natural -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural

type Compare (a :: Natural) (b :: Natural)

Defined in GHC.Internal.Data.Type.Ord

type Compare (a :: Natural) (b :: Natural) = CmpNat a b

Combinators

integerToBounded :: (Integral a, Bounded a) => Integer -> Maybe a

Transforms an integer number to a bounded integral. It returns Nothing for integers outside the bound of the return type.

>>> integerToBounded @Int 42
Just 42

>>> integerToBounded @Int8 1024
Nothing

>>> integerToBounded @Int (toInteger (minBound :: Int))
Just (-9223372036854775808)
>>> integerToBounded @Int $ (toInteger (minBound :: Int)) - 1
Nothing

>>> integerToBounded @Int (toInteger (maxBound :: Int))
Just 9223372036854775807
>>> integerToBounded @Int $ (toInteger (maxBound :: Int)) + 1
Nothing

If you want to convert Int or Word to a bounded type, take a look at toIntegralSized function instead.

Since: 0.5.0

integerToNatural :: Integer -> Maybe Natural

Transforms an integer number to a natural. Only non-negative integers are considered natural, everything else will return Nothing.

>>> integerToNatural (-1)
Nothing

>>> integerToNatural 0
Just 0

>>> integerToNatural 10
Just 10

Since: 0.5.0