GHC.Num

The Num class and the Integer type.

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

Num CBool

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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 Int16

Since: base-2.1

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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.1

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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

Defined in GHC.Word

Methods

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

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

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

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Num CBlkCnt

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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

Defined in 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 Integer

Since: base-2.1

Defined in GHC.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.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

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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 (Identity a)

Since: base-4.9.0.0

Defined in 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 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 (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 (Product a)

Since: base-4.7.0.0

Defined in 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 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.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 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 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 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

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

Deprecated: Use integerQuotRem# instead

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.

module GHC.Num.Integer

module GHC.Num.Natural

data Natural

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Instances

Data Natural

Since: base-4.8.0.0

Defined in 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

Bits Natural

Since: base-4.8.0

Defined in GHC.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

Enum Natural

Since: base-4.8.0.0

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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.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.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.Real

Methods

toRational :: Natural -> Rational

Show Natural

Since: base-4.8.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

PrintfArg Natural

Since: base-4.8.0.0

Defined in Text.Printf

Methods

formatArg :: Natural -> FieldFormatter

parseFormat :: Natural -> ModifierParser

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

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.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.TypeNats

Methods

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

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

Defined in 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 (fit into an Int), IS constructor is used. Otherwise IP and IN constructors are used to store a BigNat representing respectively the positive or the negative value magnitude.

Invariant: IP and IN are used iff value doesn't fit in IS

Instances

Data Integer

Since: base-4.0.0.0

Defined in 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

Bits Integer

Since: base-2.1

Defined in GHC.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

Enum Integer

Since: base-2.1

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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

Defined in GHC.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.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.Real

Methods

toRational :: Integer -> Rational

Show Integer

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

PrintfArg Integer

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Integer -> FieldFormatter

parseFormat :: Integer -> ModifierParser

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