Hoogle Search

Within LTS Haskell 23.24 (ghc-9.8.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. class Num a

    base 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)
    • 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.

  2. module GHC.Num

    The Num class and the Integer type.

  3. class Num a

    base GHC.Num

    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.

  4. class Num a

    hedgehog Hedgehog.Internal.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)
    • 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.

  5. module GHC.Num

    No documentation available.

  6. class Num a

    rio RIO.Prelude.Types

    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.

  7. class Num a

    Cabal-syntax Distribution.Compat.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)
    • 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.

  8. class Num a

    relude Relude.Numeric

    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.

  9. Num :: Annotation

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

    No documentation available.

  10. class Num a

    protolude Protolude

    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.

Page 1 of many | Next