num -is:module
Parse an integral number.
base Prelude GHC.Num,
hedgehog Hedgehog.Internal.Prelude,
protolude Protolude Protolude.Base,
relude Relude.Numeric,
Cabal-syntax Distribution.Compat.Prelude,
numhask NumHask.Prelude,
ghc-lib-parser GHC.Prelude.Basic,
ghc-internal GHC.Internal.Num,
xmonad-contrib XMonad.Config.Prime,
copilot-language Copilot.Language.Prelude,
incipit-base Incipit.Base,
cabal-install-solver Distribution.Solver.Compat.Prelude,
subcategories Control.Subcategory.RebindableSyntax,
verset Verset,
hledger-web Hledger.Web.Import 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.
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.
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.
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.
Simple coordinate in current user coordinate.
NUM Corresponds to the `#NUM`! error.
Extract the numerator of the ratio in reduced form: the numerator and
denominator have no common factor and the denominator is positive.
The number of elements in the array.
Returns the number of sparks in the local spark pool.