Num -package:haha -package:github -is:module
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.
hedgehog Hedgehog.Internal.Prelude,
base-compat Prelude.Compat,
protolude Protolude Protolude.Base,
relude Relude.Numeric,
rio RIO.Prelude.Types,
base-prelude BasePrelude,
classy-prelude ClassyPrelude,
universum Universum.Base,
Cabal-syntax Distribution.Compat.Prelude,
numhask NumHask.Prelude,
ghc-lib-parser GHC.Prelude.Basic,
dimensional Numeric.Units.Dimensional.Prelude,
rebase Rebase.Prelude,
xmonad-contrib XMonad.Config.Prime,
stack Stack.Prelude,
incipit-base Incipit.Base,
LambdaHack Game.LambdaHack.Core.Prelude,
cabal-install-solver Distribution.Solver.Compat.Prelude,
subcategories Control.Subcategory.RebindableSyntax,
yesod-paginator Yesod.Paginator.Prelude,
distribution-opensuse OpenSuse.Prelude,
faktory Faktory.Prelude,
hledger-web Hledger.Web.Import,
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.
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.
Simple coordinate in current user coordinate.
Parse an integral number number.
e.g. 123e456, 123e-456 or 123.456E-967
Numbers
We preserve whether the number was integral, decimal or in scientific
form.
Number of parallel threads to use for running tests.
Note that this is
not included in
coreOptions. Instead,
it's automatically included in the options for any
TestReporter
ingredient by
ingredientOptions, because the way test reporters
are handled already involves parallelism. Other ingredients may also
choose to include this option.