Prelude.YAP

A replacement for the standard Prelude, aiming to preserve compatibility for clients as far as possible. To use this module, you'll need to turn on RebindableSyntax, which also turns off the implicit import of the standard Prelude.

For greater backwards compatibility, this module hides the names of the classes AbelianGroup, Ring, Field and EuclideanDomain, and their new methods zero, unit and associate. To use those names, e.g. to define instances, you'll also need to import Data.YAP.Algebra.

Standard Haskell prelude

module Prelude

Compatibility classes

module Data.YAP.Algebra

class Ring a => Num a where

Haskell 98 compatibility class

Methods

abs :: a -> a

Absolute value.

signum :: a -> a

Sign of a number. The functions abs and signum should satisfy the law:

 abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

Instances

Num Double

Num Float

Num Int

Num Integer

(Integral a, Integral a) => Num (Ratio a)

RealFloat a => Num (Complex a)

class (Num a, Ord a) => Real a where

unchanged from Haskell 98

Methods

toRational :: a -> Rational

The rational equivalent of its real argument with full precision

Instances

Real Double

Real Float

Real Int

Real Integer

(Integral a, Integral a) => Real (Ratio a)

class (Num a, Field a) => Fractional a where

Haskell 98 compatibility class

Methods

fromRational :: Rational -> a

Convert from Rational

A floating point numeric literal represents the application of the function fromRational to the appropriate value of type Rational, so such literals have type (Field a) => a.

Instances

Fractional Double

Fractional Float

(Integral a, Integral a) => Fractional (Ratio a)

RealFloat a => Fractional (Complex a)

class (Real a, Enum a, EuclideanDomain a) => Integral a where

Integral numbers, supporting integer division.

Minimal complete definition: toInteger.

Methods

quot :: a -> a -> a

Integer division truncated toward zero

rem :: a -> a -> a

Integer remainder, satisfying

 (x `quot` y)*y + (x `rem` y) == x

quotRem :: a -> a -> (a, a)

simultaneous quot and rem

toInteger :: a -> Integer

Conversion to Integer

Instances

Integral Int

Integral Integer

Unchanged classes

class (Real a, Fractional a) => RealFrac a where

unchanged from Haskell 98

Methods

properFraction :: Integral b => a -> (b, a)

truncate, round :: Integral b => a -> b

ceiling, floor :: Integral b => a -> b

Instances

RealFrac Double

RealFrac Float

(Integral a, Integral a) => RealFrac (Ratio a)

class Fractional a => Floating a where

unchanged from Haskell 98

Methods

pi :: a

exp, sqrt, log :: a -> a

(**), logBase :: a -> a -> a

sin, tan, cos :: a -> a

asin, atan, acos :: a -> a

sinh, tanh, cosh :: a -> a

asinh, atanh, acosh :: a -> a

Instances

Floating Double

Floating Float

RealFloat a => Floating (Complex a)

class (RealFrac a, Floating a) => RealFloat a where

unchanged from Haskell 98

Methods

floatRadix :: a -> Integer

floatDigits :: a -> Int

floatRange :: a -> (Int, Int)

decodeFloat :: a -> (Integer, Int)

encodeFloat :: Integer -> Int -> a

exponent :: a -> Int

significand :: a -> a

scaleFloat :: Int -> a -> a

isNaN, isIEEE, isNegativeZero, isDenormalized, isInfinite :: a -> Bool

atan2 :: a -> a -> a

Instances

RealFloat Double

RealFloat Float

Numeric functions

even, odd :: Integral a => a -> Bool

(^) :: (Ring a, Integral b) => a -> b -> a

raise a number to a non-negative integral power

(^^) :: (Field a, Integral b) => a -> b -> a

raise a number to an integral power

fromIntegral :: (Integral a, Ring b) => a -> b

General conversion from integral types, via the Integer type.

realToFrac :: (Real a, Fractional b) => a -> b

General conversion to fields, via the Rational type.