Copyright	(c) The University of Glasgow 1994-2002
License	see libraries/base/LICENSE
Maintainer	ghc-devs@haskell.org
Stability	internal
Portability	non-portable (GHC Extensions)
Safe Haskell	Trustworthy
Language	Haskell2010

GHC.Internal.Num

Description

The Num class and the Integer type.

Synopsis

class Num a where
- (+) :: a -> a -> a
- (-) :: a -> a -> a
- (*) :: a -> a -> a
- negate :: a -> a
- abs :: a -> a
- signum :: a -> a
- fromInteger :: Integer -> a
subtract :: Num a => a -> a -> a
quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
module GHC.Internal.Bignum.Integer
module GHC.Internal.Bignum.Natural
data Natural
data Integer

Documentation

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

Instances details

Num CBool #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CBool -> CBool -> CBool # (-) :: CBool -> CBool -> CBool # (*) :: CBool -> CBool -> CBool # negate :: CBool -> CBool # abs :: CBool -> CBool # signum :: CBool -> CBool # fromInteger :: Integer -> CBool #
Num CChar #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CChar -> CChar -> CChar # (-) :: CChar -> CChar -> CChar # (*) :: CChar -> CChar -> CChar # negate :: CChar -> CChar # abs :: CChar -> CChar # signum :: CChar -> CChar # fromInteger :: Integer -> CChar #
Num CClock #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CClock -> CClock -> CClock # (-) :: CClock -> CClock -> CClock # (*) :: CClock -> CClock -> CClock # negate :: CClock -> CClock # abs :: CClock -> CClock # signum :: CClock -> CClock # fromInteger :: Integer -> CClock #
Num CDouble #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CDouble -> CDouble -> CDouble # (-) :: CDouble -> CDouble -> CDouble # (*) :: CDouble -> CDouble -> CDouble # negate :: CDouble -> CDouble # abs :: CDouble -> CDouble # signum :: CDouble -> CDouble # fromInteger :: Integer -> CDouble #
Num CFloat #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CFloat -> CFloat -> CFloat # (-) :: CFloat -> CFloat -> CFloat # (*) :: CFloat -> CFloat -> CFloat # negate :: CFloat -> CFloat # abs :: CFloat -> CFloat # signum :: CFloat -> CFloat # fromInteger :: Integer -> CFloat #
Num CInt #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CInt -> CInt -> CInt # (-) :: CInt -> CInt -> CInt # (*) :: CInt -> CInt -> CInt # negate :: CInt -> CInt # abs :: CInt -> CInt # signum :: CInt -> CInt # fromInteger :: Integer -> CInt #
Num CIntMax #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CIntMax -> CIntMax -> CIntMax # (-) :: CIntMax -> CIntMax -> CIntMax # (*) :: CIntMax -> CIntMax -> CIntMax # negate :: CIntMax -> CIntMax # abs :: CIntMax -> CIntMax # signum :: CIntMax -> CIntMax # fromInteger :: Integer -> CIntMax #
Num CIntPtr #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CIntPtr -> CIntPtr -> CIntPtr # (-) :: CIntPtr -> CIntPtr -> CIntPtr # (*) :: CIntPtr -> CIntPtr -> CIntPtr # negate :: CIntPtr -> CIntPtr # abs :: CIntPtr -> CIntPtr # signum :: CIntPtr -> CIntPtr # fromInteger :: Integer -> CIntPtr #
Num CLLong #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CLLong -> CLLong -> CLLong # (-) :: CLLong -> CLLong -> CLLong # (*) :: CLLong -> CLLong -> CLLong # negate :: CLLong -> CLLong # abs :: CLLong -> CLLong # signum :: CLLong -> CLLong # fromInteger :: Integer -> CLLong #
Num CLong #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CLong -> CLong -> CLong # (-) :: CLong -> CLong -> CLong # (*) :: CLong -> CLong -> CLong # negate :: CLong -> CLong # abs :: CLong -> CLong # signum :: CLong -> CLong # fromInteger :: Integer -> CLong #
Num CPtrdiff #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (-) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (*) :: CPtrdiff -> CPtrdiff -> CPtrdiff # negate :: CPtrdiff -> CPtrdiff # abs :: CPtrdiff -> CPtrdiff # signum :: CPtrdiff -> CPtrdiff # fromInteger :: Integer -> CPtrdiff #
Num CSChar #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CSChar -> CSChar -> CSChar # (-) :: CSChar -> CSChar -> CSChar # (*) :: CSChar -> CSChar -> CSChar # negate :: CSChar -> CSChar # abs :: CSChar -> CSChar # signum :: CSChar -> CSChar # fromInteger :: Integer -> CSChar #
Num CSUSeconds #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (-) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds # negate :: CSUSeconds -> CSUSeconds # abs :: CSUSeconds -> CSUSeconds # signum :: CSUSeconds -> CSUSeconds # fromInteger :: Integer -> CSUSeconds #
Num CShort #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CShort -> CShort -> CShort # (-) :: CShort -> CShort -> CShort # (*) :: CShort -> CShort -> CShort # negate :: CShort -> CShort # abs :: CShort -> CShort # signum :: CShort -> CShort # fromInteger :: Integer -> CShort #
Num CSigAtomic #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (-) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic # negate :: CSigAtomic -> CSigAtomic # abs :: CSigAtomic -> CSigAtomic # signum :: CSigAtomic -> CSigAtomic # fromInteger :: Integer -> CSigAtomic #
Num CSize #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CSize -> CSize -> CSize # (-) :: CSize -> CSize -> CSize # (*) :: CSize -> CSize -> CSize # negate :: CSize -> CSize # abs :: CSize -> CSize # signum :: CSize -> CSize # fromInteger :: Integer -> CSize #
Num CTime #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CTime -> CTime -> CTime # (-) :: CTime -> CTime -> CTime # (*) :: CTime -> CTime -> CTime # negate :: CTime -> CTime # abs :: CTime -> CTime # signum :: CTime -> CTime # fromInteger :: Integer -> CTime #
Num CUChar #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUChar -> CUChar -> CUChar # (-) :: CUChar -> CUChar -> CUChar # (*) :: CUChar -> CUChar -> CUChar # negate :: CUChar -> CUChar # abs :: CUChar -> CUChar # signum :: CUChar -> CUChar # fromInteger :: Integer -> CUChar #
Num CUInt #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUInt -> CUInt -> CUInt # (-) :: CUInt -> CUInt -> CUInt # (*) :: CUInt -> CUInt -> CUInt # negate :: CUInt -> CUInt # abs :: CUInt -> CUInt # signum :: CUInt -> CUInt # fromInteger :: Integer -> CUInt #
Num CUIntMax #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUIntMax -> CUIntMax -> CUIntMax # (-) :: CUIntMax -> CUIntMax -> CUIntMax # (*) :: CUIntMax -> CUIntMax -> CUIntMax # negate :: CUIntMax -> CUIntMax # abs :: CUIntMax -> CUIntMax # signum :: CUIntMax -> CUIntMax # fromInteger :: Integer -> CUIntMax #
Num CUIntPtr #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (-) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (*) :: CUIntPtr -> CUIntPtr -> CUIntPtr # negate :: CUIntPtr -> CUIntPtr # abs :: CUIntPtr -> CUIntPtr # signum :: CUIntPtr -> CUIntPtr # fromInteger :: Integer -> CUIntPtr #
Num CULLong #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CULLong -> CULLong -> CULLong # (-) :: CULLong -> CULLong -> CULLong # (*) :: CULLong -> CULLong -> CULLong # negate :: CULLong -> CULLong # abs :: CULLong -> CULLong # signum :: CULLong -> CULLong # fromInteger :: Integer -> CULLong #
Num CULong #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CULong -> CULong -> CULong # (-) :: CULong -> CULong -> CULong # (*) :: CULong -> CULong -> CULong # negate :: CULong -> CULong # abs :: CULong -> CULong # signum :: CULong -> CULong # fromInteger :: Integer -> CULong #
Num CUSeconds #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUSeconds -> CUSeconds -> CUSeconds # (-) :: CUSeconds -> CUSeconds -> CUSeconds # (*) :: CUSeconds -> CUSeconds -> CUSeconds # negate :: CUSeconds -> CUSeconds # abs :: CUSeconds -> CUSeconds # signum :: CUSeconds -> CUSeconds # fromInteger :: Integer -> CUSeconds #
Num CUShort #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CUShort -> CUShort -> CUShort # (-) :: CUShort -> CUShort -> CUShort # (*) :: CUShort -> CUShort -> CUShort # negate :: CUShort -> CUShort # abs :: CUShort -> CUShort # signum :: CUShort -> CUShort # fromInteger :: Integer -> CUShort #
Num CWchar #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods (+) :: CWchar -> CWchar -> CWchar # (-) :: CWchar -> CWchar -> CWchar # (*) :: CWchar -> CWchar -> CWchar # negate :: CWchar -> CWchar # abs :: CWchar -> CWchar # signum :: CWchar -> CWchar # fromInteger :: Integer -> CWchar #
Num IntPtr #
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (+) :: IntPtr -> IntPtr -> IntPtr # (-) :: IntPtr -> IntPtr -> IntPtr # (*) :: IntPtr -> IntPtr -> IntPtr # negate :: IntPtr -> IntPtr # abs :: IntPtr -> IntPtr # signum :: IntPtr -> IntPtr # fromInteger :: Integer -> IntPtr #
Num WordPtr #
Instance details Defined in GHC.Internal.Foreign.Ptr Methods (+) :: WordPtr -> WordPtr -> WordPtr # (-) :: WordPtr -> WordPtr -> WordPtr # (*) :: WordPtr -> WordPtr -> WordPtr # negate :: WordPtr -> WordPtr # abs :: WordPtr -> WordPtr # signum :: WordPtr -> WordPtr # fromInteger :: Integer -> WordPtr #
Num HalfWord #
Instance details Defined in GHC.Internal.Heap.InfoTable.Types Methods (+) :: HalfWord -> HalfWord -> HalfWord # (-) :: HalfWord -> HalfWord -> HalfWord # (*) :: HalfWord -> HalfWord -> HalfWord # negate :: HalfWord -> HalfWord # abs :: HalfWord -> HalfWord # signum :: HalfWord -> HalfWord # fromInteger :: Integer -> HalfWord #
Num Int16 #	Since: base-2.1
Instance details 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.1
Instance details 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.1
Instance details 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.1
Instance details 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 ByteOffset #
Instance details Defined in GHC.Internal.Stack.Constants Methods (+) :: ByteOffset -> ByteOffset -> ByteOffset # (-) :: ByteOffset -> ByteOffset -> ByteOffset # (*) :: ByteOffset -> ByteOffset -> ByteOffset # negate :: ByteOffset -> ByteOffset # abs :: ByteOffset -> ByteOffset # signum :: ByteOffset -> ByteOffset # fromInteger :: Integer -> ByteOffset #
Num WordOffset #
Instance details Defined in GHC.Internal.Stack.Constants Methods (+) :: WordOffset -> WordOffset -> WordOffset # (-) :: WordOffset -> WordOffset -> WordOffset # (*) :: WordOffset -> WordOffset -> WordOffset # negate :: WordOffset -> WordOffset # abs :: WordOffset -> WordOffset # signum :: WordOffset -> WordOffset # fromInteger :: Integer -> WordOffset #
Num ByteOffset #
Instance details Defined in GHC.Internal.Stack.ConstantsProf Methods (+) :: ByteOffset -> ByteOffset -> ByteOffset # (-) :: ByteOffset -> ByteOffset -> ByteOffset # (*) :: ByteOffset -> ByteOffset -> ByteOffset # negate :: ByteOffset -> ByteOffset # abs :: ByteOffset -> ByteOffset # signum :: ByteOffset -> ByteOffset # fromInteger :: Integer -> ByteOffset #
Num WordOffset #
Instance details Defined in GHC.Internal.Stack.ConstantsProf Methods (+) :: WordOffset -> WordOffset -> WordOffset # (-) :: WordOffset -> WordOffset -> WordOffset # (*) :: WordOffset -> WordOffset -> WordOffset # negate :: WordOffset -> WordOffset # abs :: WordOffset -> WordOffset # signum :: WordOffset -> WordOffset # fromInteger :: Integer -> WordOffset #
Num CBlkCnt #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CBlkCnt -> CBlkCnt -> CBlkCnt # (-) :: CBlkCnt -> CBlkCnt -> CBlkCnt # (*) :: CBlkCnt -> CBlkCnt -> CBlkCnt # negate :: CBlkCnt -> CBlkCnt # abs :: CBlkCnt -> CBlkCnt # signum :: CBlkCnt -> CBlkCnt # fromInteger :: Integer -> CBlkCnt #
Num CBlkSize #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CBlkSize -> CBlkSize -> CBlkSize # (-) :: CBlkSize -> CBlkSize -> CBlkSize # (*) :: CBlkSize -> CBlkSize -> CBlkSize # negate :: CBlkSize -> CBlkSize # abs :: CBlkSize -> CBlkSize # signum :: CBlkSize -> CBlkSize # fromInteger :: Integer -> CBlkSize #
Num CCc #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CCc -> CCc -> CCc # (-) :: CCc -> CCc -> CCc # (*) :: CCc -> CCc -> CCc # negate :: CCc -> CCc # abs :: CCc -> CCc # signum :: CCc -> CCc # fromInteger :: Integer -> CCc #
Num CClockId #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CClockId -> CClockId -> CClockId # (-) :: CClockId -> CClockId -> CClockId # (*) :: CClockId -> CClockId -> CClockId # negate :: CClockId -> CClockId # abs :: CClockId -> CClockId # signum :: CClockId -> CClockId # fromInteger :: Integer -> CClockId #
Num CDev #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CDev -> CDev -> CDev # (-) :: CDev -> CDev -> CDev # (*) :: CDev -> CDev -> CDev # negate :: CDev -> CDev # abs :: CDev -> CDev # signum :: CDev -> CDev # fromInteger :: Integer -> CDev #
Num CFsBlkCnt #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # (-) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # (*) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # negate :: CFsBlkCnt -> CFsBlkCnt # abs :: CFsBlkCnt -> CFsBlkCnt # signum :: CFsBlkCnt -> CFsBlkCnt # fromInteger :: Integer -> CFsBlkCnt #
Num CFsFilCnt #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # (-) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # (*) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # negate :: CFsFilCnt -> CFsFilCnt # abs :: CFsFilCnt -> CFsFilCnt # signum :: CFsFilCnt -> CFsFilCnt # fromInteger :: Integer -> CFsFilCnt #
Num CGid #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CGid -> CGid -> CGid # (-) :: CGid -> CGid -> CGid # (*) :: CGid -> CGid -> CGid # negate :: CGid -> CGid # abs :: CGid -> CGid # signum :: CGid -> CGid # fromInteger :: Integer -> CGid #
Num CId #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CId -> CId -> CId # (-) :: CId -> CId -> CId # (*) :: CId -> CId -> CId # negate :: CId -> CId # abs :: CId -> CId # signum :: CId -> CId # fromInteger :: Integer -> CId #
Num CIno #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CIno -> CIno -> CIno # (-) :: CIno -> CIno -> CIno # (*) :: CIno -> CIno -> CIno # negate :: CIno -> CIno # abs :: CIno -> CIno # signum :: CIno -> CIno # fromInteger :: Integer -> CIno #
Num CKey #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CKey -> CKey -> CKey # (-) :: CKey -> CKey -> CKey # (*) :: CKey -> CKey -> CKey # negate :: CKey -> CKey # abs :: CKey -> CKey # signum :: CKey -> CKey # fromInteger :: Integer -> CKey #
Num CMode #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CMode -> CMode -> CMode # (-) :: CMode -> CMode -> CMode # (*) :: CMode -> CMode -> CMode # negate :: CMode -> CMode # abs :: CMode -> CMode # signum :: CMode -> CMode # fromInteger :: Integer -> CMode #
Num CNfds #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CNfds -> CNfds -> CNfds # (-) :: CNfds -> CNfds -> CNfds # (*) :: CNfds -> CNfds -> CNfds # negate :: CNfds -> CNfds # abs :: CNfds -> CNfds # signum :: CNfds -> CNfds # fromInteger :: Integer -> CNfds #
Num CNlink #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CNlink -> CNlink -> CNlink # (-) :: CNlink -> CNlink -> CNlink # (*) :: CNlink -> CNlink -> CNlink # negate :: CNlink -> CNlink # abs :: CNlink -> CNlink # signum :: CNlink -> CNlink # fromInteger :: Integer -> CNlink #
Num COff #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: COff -> COff -> COff # (-) :: COff -> COff -> COff # (*) :: COff -> COff -> COff # negate :: COff -> COff # abs :: COff -> COff # signum :: COff -> COff # fromInteger :: Integer -> COff #
Num CPid #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CPid -> CPid -> CPid # (-) :: CPid -> CPid -> CPid # (*) :: CPid -> CPid -> CPid # negate :: CPid -> CPid # abs :: CPid -> CPid # signum :: CPid -> CPid # fromInteger :: Integer -> CPid #
Num CRLim #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CRLim -> CRLim -> CRLim # (-) :: CRLim -> CRLim -> CRLim # (*) :: CRLim -> CRLim -> CRLim # negate :: CRLim -> CRLim # abs :: CRLim -> CRLim # signum :: CRLim -> CRLim # fromInteger :: Integer -> CRLim #
Num CSocklen #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CSocklen -> CSocklen -> CSocklen # (-) :: CSocklen -> CSocklen -> CSocklen # (*) :: CSocklen -> CSocklen -> CSocklen # negate :: CSocklen -> CSocklen # abs :: CSocklen -> CSocklen # signum :: CSocklen -> CSocklen # fromInteger :: Integer -> CSocklen #
Num CSpeed #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CSpeed -> CSpeed -> CSpeed # (-) :: CSpeed -> CSpeed -> CSpeed # (*) :: CSpeed -> CSpeed -> CSpeed # negate :: CSpeed -> CSpeed # abs :: CSpeed -> CSpeed # signum :: CSpeed -> CSpeed # fromInteger :: Integer -> CSpeed #
Num CSsize #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CSsize -> CSsize -> CSsize # (-) :: CSsize -> CSsize -> CSsize # (*) :: CSsize -> CSsize -> CSsize # negate :: CSsize -> CSsize # abs :: CSsize -> CSsize # signum :: CSsize -> CSsize # fromInteger :: Integer -> CSsize #
Num CTcflag #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CTcflag -> CTcflag -> CTcflag # (-) :: CTcflag -> CTcflag -> CTcflag # (*) :: CTcflag -> CTcflag -> CTcflag # negate :: CTcflag -> CTcflag # abs :: CTcflag -> CTcflag # signum :: CTcflag -> CTcflag # fromInteger :: Integer -> CTcflag #
Num CUid #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CUid -> CUid -> CUid # (-) :: CUid -> CUid -> CUid # (*) :: CUid -> CUid -> CUid # negate :: CUid -> CUid # abs :: CUid -> CUid # signum :: CUid -> CUid # fromInteger :: Integer -> CUid #
Num Fd #
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: Fd -> Fd -> Fd # (-) :: Fd -> Fd -> Fd # (*) :: Fd -> Fd -> Fd # negate :: Fd -> Fd # abs :: Fd -> Fd # signum :: Fd -> Fd # fromInteger :: Integer -> Fd #
Num Word16 #	Since: base-2.1
Instance details 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.1
Instance details 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.1
Instance details 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.1
Instance details 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 Integer #	Since: base-2.1
Instance details 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
Instance details 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 Double #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive: `>>>` `(0.1 + 0.1) + 0.4 == 0.1 + (0.1 + 0.4)`False `>>>` *`(0.1 + 0.2) 0.3 == 0.1 * 0.3 + 0.2 * 0.3`False `>>>` `(0.1 * 0.1) * 0.3 == 0.1 * (0.1 * 0.3)`*False Since: base-2.1*
Instance details Defined in GHC.Internal.Float Methods (+) :: Double -> Double -> Double # (-) :: Double -> Double -> Double # (*) :: Double -> Double -> Double # negate :: Double -> Double # abs :: Double -> Double # signum :: Double -> Double # fromInteger :: Integer -> Double #
Num Float #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive: `>>>` `(0.1 + 0.1 :: Float) + 0.5 == 0.1 + (0.1 + 0.5)`False `>>>` *`(0.1 + 0.2 :: Float) 0.9 == 0.1 * 0.9 + 0.2 * 0.9`False `>>>` `(0.1 * 0.1 :: Float) * 0.9 == 0.1 * (0.1 * 0.9)`*False Since: base-2.1*
Instance details Defined in GHC.Internal.Float Methods (+) :: Float -> Float -> Float # (-) :: Float -> Float -> Float # (*) :: Float -> Float -> Float # negate :: Float -> Float # abs :: Float -> Float # signum :: Float -> Float # fromInteger :: Integer -> Float #
Num Int #	Since: base-2.1
Instance details 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.1
Instance details 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 #
Num a => Num (Identity a) #	Since: base-4.9.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 #
Num a => Num (Const a b) #	Since: base-4.9.0.0
Instance details 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 `Applicative`s, 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*
Instance details 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
Instance details 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 #

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.

quotRemInteger :: Integer -> Integer -> (# Integer, Integer #) #

Deprecated: Use integerQuotRem# instead

module GHC.Internal.Bignum.Integer

module GHC.Internal.Bignum.Natural

data Natural #

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Instances

Instances details

Bits Natural #	Since: base-4.8.0
Instance details 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 #
Eq Natural #
Instance details Defined in GHC.Internal.Bignum.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Ord Natural #
Instance details Defined in GHC.Internal.Bignum.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 #
Data Natural #	Since: base-4.8.0.0
Instance details 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
Instance details 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] #
Ix Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Ix Methods range :: (Natural, Natural) -> [Natural] # index :: (Natural, Natural) -> Natural -> Int # unsafeIndex :: (Natural, Natural) -> Natural -> Int # inRange :: (Natural, Natural) -> Natural -> Bool # rangeSize :: (Natural, Natural) -> Int # unsafeRangeSize :: (Natural, Natural) -> Int #
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
Instance details 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
Instance details 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
Instance details 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
Instance details Defined in GHC.Internal.Real Methods toRational :: Natural -> Rational #
Show Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
TestCoercion SNat #	Since: base-4.18.0.0
Instance details 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
Instance details Defined in GHC.Internal.TypeNats Methods testEquality :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (a :~: b) #
Lift Natural #
Instance details Defined in GHC.Internal.TH.Lift Methods lift :: Quote m => Natural -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural #
type Compare (a :: Natural) (b :: Natural) #
Instance details Defined in GHC.Internal.Data.Type.Ord type Compare (a :: Natural) (b :: Natural) = CmpNat a b

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

Instances details

Bits Integer #	Since: base-2.1
Instance details 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 #
Eq Integer #
Instance details Defined in GHC.Internal.Bignum.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Ord Integer #
Instance details Defined in GHC.Internal.Bignum.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 #
Data Integer #	Since: base-4.0.0.0
Instance details 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.1
Instance details 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] #
Ix Integer #	Since: base-2.1
Instance details Defined in GHC.Internal.Ix Methods range :: (Integer, Integer) -> [Integer] # index :: (Integer, Integer) -> Integer -> Int # unsafeIndex :: (Integer, Integer) -> Integer -> Int # inRange :: (Integer, Integer) -> Integer -> Bool # rangeSize :: (Integer, Integer) -> Int # unsafeRangeSize :: (Integer, Integer) -> Int #
Num Integer #	Since: base-2.1
Instance details 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.1
Instance details 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
Instance details 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
Instance details Defined in GHC.Internal.Real Methods toRational :: Integer -> Rational #
Show Integer #	Since: base-2.1
Instance details Defined in GHC.Internal.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Lift Integer #
Instance details Defined in GHC.Internal.TH.Lift Methods lift :: Quote m => Integer -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer #