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:
*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.

**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)`if the type also implements Integral, then fromInteger is a left inverse for toInteger, i.e.**Coherence with**`toInteger``fromInteger (toInteger i) == i`

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, ihaskell IHaskellPrelude, 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, freckle-app Freckle.App.Prelude Freckle.App.Test, 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:
*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.

**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)`

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:
*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.

**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)`if the type also implements Integral, then fromInteger is a left inverse for toInteger, i.e.**Coherence with**`toInteger``fromInteger (toInteger i) == i`

Numeric instances for Convertible.
Copyright (C) 2009-2011 John Goerzen jgoerzen@complete.org
All rights reserved.
For license and copyright information, see the file LICENSE
These instances perform conversion between numeric types such as
Double, Int, Integer, Rational, and the like. Here are some notes
about the conversion process:
Conversions from floating-point types such as Double to integral types
are done via the truncate function. This is a somewhat
arbitrary decision; if you need different behavior, you will have to
write your own instance or manually perform the conversion.
All conversions perform bounds checking. If a value is too large for
its destination type, you will get a ConvertError informing you
of this. Note that this behavior differs from functions in the Haskell
standard libraries, which will perform the conversion without error,
but give you garbage in the end.
Conversions do not perform precision checking; loss of precision is
implied with certain conversions (for instance, Double to Float) and
this is not an error.

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:
*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.

**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)`

Number instances for MSFs that produce numbers. This allows you
to use numeric operators with MSFs that output numbers, for
example, you can write:

msf1 :: MSF Input Double -- defined however you want msf2 :: MSF Input Double -- defined however you want msf3 :: MSF Input Double msf3 = msf1 + msf2instead of

msf3 = (msf1 &&& msf2) >>> arr (uncurry (+))Instances are provided for the type classes Num, Fractional and Floating.

Simple coordinate in current user coordinate.

Defines a D10 type as a newtype for any type with an instance
of the Num class, where the values are restricted to numbers
between `fromInteger 0` and `fromInteger
9`.
This module provides many functions for constructing D10
values, including:

integerD10Maybe :: Num a => Integer -> Maybe (D10 a)

integerMod10 :: Num a => Integer -> D10 a

- With the
`QuasiQuotes`GHC extension enabled, you can write use the quasi-quoters d10 and d10list. - With the
`TemplateHaskell`GHC extension enabled, you can splice expressions produced by d10Exp and d10ListExp.

Parse an integral number number.

**Packages**- is:exact
- is:module
- base
- hedgehog
- base-compat
- protolude
- relude
- rio
- base-prelude
- classy-prelude
- universum
- ihaskell
- Cabal-syntax
- numhask
- ghc-lib-parser
- dimensional
- rebase
- xmonad-contrib
- stack
- incipit-base
- LambdaHack
- cabal-install-solver
- subcategories
- yesod-paginator
- distribution-opensuse
- faktory
- freckle-app
- hledger-web
- termonad
- ghc
- convertible
- mixed-types-num
- graphviz
- pretty-simple
- rerebase
- checkers
- basic-prelude
- tfp
- prelude-compat
- dunai
- libBF
- linear-base
- svg-tree
- type-level-numbers
- d10
- rel8
- hledger-lib
- hledger
- ghc-events
- haha
- numeric-quest