Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

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

  1. class Num a

    numhask NumHask.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. class Num a

    basic-prelude CorePrelude

    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.

  3. class Num a

    classy-prelude ClassyPrelude

    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

    ghc-lib-parser GHC.Prelude.Basic

    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. Num :: Integer -> Int64 -> BFNum

    libBF LibBF 

    x * 2 ^ y

  6. Num :: Integer -> Int64 -> BFNum

    libBF LibBF.Mutable 

    x * 2 ^ y

  7. module Type.Data.Num

    No documentation available.

  8. module Test.QuickCheck.Instances.Num

    No documentation available.

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

  10. module Rebase.GHC.Num

    No documentation available.

Page 3 of many | Previous | Next