Numeric.Num

Documentation

class Num a where

Basic numeric class.

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

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

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

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

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

negate :: Natural -> Natural

abs :: Natural -> Natural

signum :: Natural -> Natural

fromInteger :: Integer -> Natural

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

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 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 Scientific

WARNING: + and - compute the Integer magnitude: 10^e where e is the difference between the base10Exponents of the arguments. If these methods are applied to arguments which have huge exponents this could fill up all space and crash your program! So don't apply these methods to scientific numbers coming from untrusted sources. The other methods can be used safely.

Defined in Data.Scientific

Methods

(+) :: Scientific -> Scientific -> Scientific

(-) :: Scientific -> Scientific -> Scientific

(*) :: Scientific -> Scientific -> Scientific

negate :: Scientific -> Scientific

abs :: Scientific -> Scientific

signum :: Scientific -> Scientific

fromInteger :: Integer -> Scientific

Num Unique

Defined in GHC.Event.Unique

Methods

(+) :: Unique -> Unique -> Unique

(-) :: Unique -> Unique -> Unique

(*) :: Unique -> Unique -> Unique

negate :: Unique -> Unique

abs :: Unique -> Unique

signum :: Unique -> Unique

fromInteger :: Integer -> Unique

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Half

Defined in Numeric.Half

Methods

(+) :: Half -> Half -> Half

(-) :: Half -> Half -> Half

(*) :: Half -> Half -> Half

negate :: Half -> Half

abs :: Half -> Half

signum :: Half -> Half

fromInteger :: Integer -> Half

Num Name

Defined in Hedgehog.Internal.State

Methods

(+) :: Name -> Name -> Name

(-) :: Name -> Name -> Name

(*) :: Name -> Name -> Name

negate :: Name -> Name

abs :: Name -> Name

signum :: Name -> Name

fromInteger :: Integer -> Name

Num TestLimit

Defined in Hedgehog.Internal.Property

Methods

(+) :: TestLimit -> TestLimit -> TestLimit

(-) :: TestLimit -> TestLimit -> TestLimit

(*) :: TestLimit -> TestLimit -> TestLimit

negate :: TestLimit -> TestLimit

abs :: TestLimit -> TestLimit

signum :: TestLimit -> TestLimit

fromInteger :: Integer -> TestLimit

Num DiscardLimit

Defined in Hedgehog.Internal.Property

Methods

(+) :: DiscardLimit -> DiscardLimit -> DiscardLimit

(-) :: DiscardLimit -> DiscardLimit -> DiscardLimit

(*) :: DiscardLimit -> DiscardLimit -> DiscardLimit

negate :: DiscardLimit -> DiscardLimit

abs :: DiscardLimit -> DiscardLimit

signum :: DiscardLimit -> DiscardLimit

fromInteger :: Integer -> DiscardLimit

Num ShrinkLimit

Defined in Hedgehog.Internal.Property

Methods

(+) :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit

(-) :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit

(*) :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit

negate :: ShrinkLimit -> ShrinkLimit

abs :: ShrinkLimit -> ShrinkLimit

signum :: ShrinkLimit -> ShrinkLimit

fromInteger :: Integer -> ShrinkLimit

Num ShrinkRetries

Defined in Hedgehog.Internal.Property

Methods

(+) :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries

(-) :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries

(*) :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries

negate :: ShrinkRetries -> ShrinkRetries

abs :: ShrinkRetries -> ShrinkRetries

signum :: ShrinkRetries -> ShrinkRetries

fromInteger :: Integer -> ShrinkRetries

Num Size

Defined in Hedgehog.Internal.Range

Methods

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

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

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

negate :: Size -> Size

abs :: Size -> Size

signum :: Size -> Size

fromInteger :: Integer -> Size

Num PortNumber

Defined in Network.Socket.Types

Methods

(+) :: PortNumber -> PortNumber -> PortNumber

(-) :: PortNumber -> PortNumber -> PortNumber

(*) :: PortNumber -> PortNumber -> PortNumber

negate :: PortNumber -> PortNumber

abs :: PortNumber -> PortNumber

signum :: PortNumber -> PortNumber

fromInteger :: Integer -> PortNumber

Num B

Defined in Data.Text.Short.Internal

Methods

(+) :: B -> B -> B

(-) :: B -> B -> B

(*) :: B -> B -> B

negate :: B -> B

abs :: B -> B

signum :: B -> B

fromInteger :: Integer -> B

Num NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

(+) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

(-) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

(*) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

negate :: NominalDiffTime -> NominalDiffTime

abs :: NominalDiffTime -> NominalDiffTime

signum :: NominalDiffTime -> NominalDiffTime

fromInteger :: Integer -> NominalDiffTime

Num DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(+) :: DiffTime -> DiffTime -> DiffTime

(-) :: DiffTime -> DiffTime -> DiffTime

(*) :: DiffTime -> DiffTime -> DiffTime

negate :: DiffTime -> DiffTime

abs :: DiffTime -> DiffTime

signum :: DiffTime -> DiffTime

fromInteger :: Integer -> DiffTime

Num CodePoint

Defined in Data.Text.Encoding

Methods

(+) :: CodePoint -> CodePoint -> CodePoint

(-) :: CodePoint -> CodePoint -> CodePoint

(*) :: CodePoint -> CodePoint -> CodePoint

negate :: CodePoint -> CodePoint

abs :: CodePoint -> CodePoint

signum :: CodePoint -> CodePoint

fromInteger :: Integer -> CodePoint

Num DecoderState

Defined in Data.Text.Encoding

Methods

(+) :: DecoderState -> DecoderState -> DecoderState

(-) :: DecoderState -> DecoderState -> DecoderState

(*) :: DecoderState -> DecoderState -> DecoderState

negate :: DecoderState -> DecoderState

abs :: DecoderState -> DecoderState

signum :: DecoderState -> DecoderState

fromInteger :: Integer -> DecoderState

Class () (Num a)

Defined in Data.Constraint

Methods

cls :: Num a :- ()

() :=> (Num Double)

Defined in Data.Constraint

Methods

ins :: () :- Num Double

() :=> (Num Float)

Defined in Data.Constraint

Methods

ins :: () :- Num Float

() :=> (Num Int)

Defined in Data.Constraint

Methods

ins :: () :- Num Int

() :=> (Num Integer)

Defined in Data.Constraint

Methods

ins :: () :- Num Integer

() :=> (Num Natural)

Defined in Data.Constraint

Methods

ins :: () :- Num Natural

() :=> (Num Word)

Defined in Data.Constraint

Methods

ins :: () :- Num Word

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

(Ord a, Num a) => Num (Approximate a)

Defined in Data.Approximate.Type

Methods

(+) :: Approximate a -> Approximate a -> Approximate a

(-) :: Approximate a -> Approximate a -> Approximate a

(*) :: Approximate a -> Approximate a -> Approximate a

negate :: Approximate a -> Approximate a

abs :: Approximate a -> Approximate a

signum :: Approximate a -> Approximate a

fromInteger :: Integer -> Approximate a

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

HasResolution a => Num (Fixed a)

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 (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 (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 (Identity a)

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 (Sum a)

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

Num a => Num (Product a)

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 (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

(Precise a, RealFloat a) => Num (Log a)

Defined in Numeric.Log

Methods

(+) :: Log a -> Log a -> Log a

(-) :: Log a -> Log a -> Log a

(*) :: Log a -> Log a -> Log a

negate :: Log a -> Log a

abs :: Log a -> Log a

signum :: Log a -> Log a

fromInteger :: Integer -> Log a

Num a => Num (Managed a)

Defined in Control.Monad.Managed

Methods

(+) :: Managed a -> Managed a -> Managed a

(-) :: Managed a -> Managed a -> Managed a

(*) :: Managed a -> Managed a -> Managed a

negate :: Managed a -> Managed a

abs :: Managed a -> Managed a

signum :: Managed a -> Managed a

fromInteger :: Integer -> Managed a

Num a => Num (Bound a)

Defined in Data.Semilattice.Bound

Methods

(+) :: Bound a -> Bound a -> Bound a

(-) :: Bound a -> Bound a -> Bound a

(*) :: Bound a -> Bound a -> Bound a

negate :: Bound a -> Bound a

abs :: Bound a -> Bound a

signum :: Bound a -> Bound a

fromInteger :: Integer -> Bound a

Num a => Num (Order a)

Defined in Data.Semilattice.Order

Methods

(+) :: Order a -> Order a -> Order a

(-) :: Order a -> Order a -> Order a

(*) :: Order a -> Order a -> Order a

negate :: Order a -> Order a

abs :: Order a -> Order a

signum :: Order a -> Order a

fromInteger :: Integer -> Order a

Num a => Num (Meeting a)

Defined in Data.Semilattice.Meet

Methods

(+) :: Meeting a -> Meeting a -> Meeting a

(-) :: Meeting a -> Meeting a -> Meeting a

(*) :: Meeting a -> Meeting a -> Meeting a

negate :: Meeting a -> Meeting a

abs :: Meeting a -> Meeting a

signum :: Meeting a -> Meeting a

fromInteger :: Integer -> Meeting a

Num a => Num (GreaterThan a)

Defined in Data.Semilattice.Meet

Methods

(+) :: GreaterThan a -> GreaterThan a -> GreaterThan a

(-) :: GreaterThan a -> GreaterThan a -> GreaterThan a

(*) :: GreaterThan a -> GreaterThan a -> GreaterThan a

negate :: GreaterThan a -> GreaterThan a

abs :: GreaterThan a -> GreaterThan a

signum :: GreaterThan a -> GreaterThan a

fromInteger :: Integer -> GreaterThan a

Num a => Num (Joining a)

Defined in Data.Semilattice.Join

Methods

(+) :: Joining a -> Joining a -> Joining a

(-) :: Joining a -> Joining a -> Joining a

(*) :: Joining a -> Joining a -> Joining a

negate :: Joining a -> Joining a

abs :: Joining a -> Joining a

signum :: Joining a -> Joining a

fromInteger :: Integer -> Joining a

Num a => Num (LessThan a)

Defined in Data.Semilattice.Join

Methods

(+) :: LessThan a -> LessThan a -> LessThan a

(-) :: LessThan a -> LessThan a -> LessThan a

(*) :: LessThan a -> LessThan a -> LessThan a

negate :: LessThan a -> LessThan a

abs :: LessThan a -> LessThan a

signum :: LessThan a -> LessThan a

fromInteger :: Integer -> LessThan a

Class (Num a) (Fractional a)

Defined in Data.Constraint

Methods

cls :: Fractional a :- Num a

(Integral a) :=> (Num (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Num (Ratio a)

(Num a) :=> (Num (Identity a))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Identity a)

(Num a) :=> (Num (Const a b))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Const a b)

(RealFloat a) :=> (Num (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Num (Complex 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 b => Num (Fold a b)

Defined in Control.Foldl

Methods

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

(-) :: Fold a b -> Fold a b -> Fold a b

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

negate :: Fold a b -> Fold a b

abs :: Fold a b -> Fold a b

signum :: Fold a b -> Fold a b

fromInteger :: Integer -> Fold a b

(Monad m, Num a) => Num (ListT m a)

Defined in List.Transformer

Methods

(+) :: ListT m a -> ListT m a -> ListT m a

(-) :: ListT m a -> ListT m a -> ListT m a

(*) :: ListT m a -> ListT m a -> ListT m a

negate :: ListT m a -> ListT m a

abs :: ListT m a -> ListT m a

signum :: ListT m a -> ListT m a

fromInteger :: Integer -> ListT m a

Class (Num a, Ord a) (Real a)

Defined in Data.Constraint

Methods

cls :: Real a :- (Num a, Ord a)

Num a => Num (Const a b)

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

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

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

(Monad m, Num b) => Num (FoldM m a b)

Defined in Control.Foldl

Methods

(+) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(-) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(*) :: FoldM m a b -> FoldM m a b -> FoldM m a b

negate :: FoldM m a b -> FoldM m a b

abs :: FoldM m a b -> FoldM m a b

signum :: FoldM m a b -> FoldM m a b

fromInteger :: Integer -> FoldM m a b

Num a => Num (Tagged s a)

Defined in Data.Tagged

Methods

(+) :: Tagged s a -> Tagged s a -> Tagged s a

(-) :: Tagged s a -> Tagged s a -> Tagged s a

(*) :: Tagged s a -> Tagged s a -> Tagged s a

negate :: Tagged s a -> Tagged s a

abs :: Tagged s a -> Tagged s a

signum :: Tagged s a -> Tagged s a

fromInteger :: Integer -> Tagged s 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.

Read

readInt

Arguments

:: Num a

=> a

the base

-> (Char -> Bool)

a predicate distinguishing valid digits in this base

-> (Char -> Int)

a function converting a valid digit character to an Int

-> ReadS a

Reads an unsigned Integral value in an arbitrary base.

readDec :: (Eq a, Num a) => ReadS a

Read an unsigned number in decimal notation.

>>> readDec "0644"
[(644,"")]

readOct :: (Eq a, Num a) => ReadS a

Read an unsigned number in octal notation.

>>> readOct "0644"
[(420,"")]

readHex :: (Eq a, Num a) => ReadS a

Read an unsigned number in hexadecimal notation. Both upper or lower case letters are allowed.

>>> readHex "deadbeef"
[(3735928559,"")]