num -is:module

Parse an integral number.

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.

class () => Num a

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.

class Num a

ghc GHC.Prelude.Basic

class Num a

rio RIO.Prelude.Types, base-prelude BasePrelude, classy-prelude ClassyPrelude, clash-prelude Clash.HaskellPrelude, constrained-categories Control.Category.Constrained.Prelude Control.Category.Hask, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude

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)

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.

Num :: Annotation

pretty-simple Text.Pretty.Simple.Internal.Printer

Num :: Number -> GraphID

graphviz Data.GraphViz.Types Data.GraphViz.Types.Canonical Data.GraphViz.Types.Generalised Data.GraphViz.Types.Graph Data.GraphViz.Types.Monadic

class Num a

basic-prelude CorePrelude

Basic numeric class.

class Num a

prelude-compat Prelude2010

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)

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.

Num :: Integer -> Int64 -> BFNum

libBF LibBF LibBF.Mutable

x * 2 ^ y

type Num a = [a]

hetero-parameter-list Data.HeteroParList

Num :: Double -> Number

svg-tree Graphics.Svg.CssTypes Graphics.Svg.Types

Simple coordinate in current user coordinate.

Num :: ErrorValueType

gogol-sheets Network.Google.Sheets Network.Google.Sheets.Types

NUM Corresponds to the `#NUM`! error.

class () => Num a

termonad Termonad.Prelude

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)

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.

numerator :: Ratio a -> a

base Data.Ratio

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

numberToFixed :: Integer -> Number -> Maybe (Integer, Integer)

base Text.Read.Lex

numberToInteger :: Number -> Maybe Integer

base Text.Read.Lex

numberToRangedRational :: (Int, Int) -> Number -> Maybe Rational

base Text.Read.Lex

numberToRational :: Number -> Rational

base Text.Read.Lex

numElements :: Array i e -> Int

base GHC.Arr

The number of elements in the array.

numElementsSTArray :: STArray s i e -> Int

base GHC.Arr