Add Haddock `/Since: 4.5.[01].0/` comments to symbols
[packages/base.git] / GHC / Num.lhs
1 \begin{code}
2 {-# LANGUAGE Trustworthy #-}
3 {-# LANGUAGE NoImplicitPrelude, MagicHash, UnboxedTuples #-}
4 {-# OPTIONS_HADDOCK hide #-}
5 -----------------------------------------------------------------------------
6 -- |
7 -- Module      :  GHC.Num
8 -- Copyright   :  (c) The University of Glasgow 1994-2002
9 -- License     :  see libraries/base/LICENSE
10 --
11 -- Maintainer  :  cvs-ghc@haskell.org
12 -- Stability   :  internal
13 -- Portability :  non-portable (GHC Extensions)
14 --
15 -- The 'Num' class and the 'Integer' type.
16 --
17 -----------------------------------------------------------------------------
18
19 -- #hide
20 module GHC.Num (module GHC.Num, module GHC.Integer) where
21
22 import GHC.Base
23 import GHC.Integer
24
25 infixl 7  *
26 infixl 6  +, -
27
28 default ()              -- Double isn't available yet,
29                         -- and we shouldn't be using defaults anyway
30 \end{code}
31
32 %*********************************************************
33 %*                                                      *
34 \subsection{Standard numeric class}
35 %*                                                      *
36 %*********************************************************
37
38 \begin{code}
39 -- | Basic numeric class.
40 --
41 -- Minimal complete definition: all except 'negate' or @(-)@
42 class  Num a  where
43     (+), (-), (*)       :: a -> a -> a
44     -- | Unary negation.
45     negate              :: a -> a
46     -- | Absolute value.
47     abs                 :: a -> a
48     -- | Sign of a number.
49     -- The functions 'abs' and 'signum' should satisfy the law:
50     --
51     -- > abs x * signum x == x
52     --
53     -- For real numbers, the 'signum' is either @-1@ (negative), @0@ (zero)
54     -- or @1@ (positive).
55     signum              :: a -> a
56     -- | Conversion from an 'Integer'.
57     -- An integer literal represents the application of the function
58     -- 'fromInteger' to the appropriate value of type 'Integer',
59     -- so such literals have type @('Num' a) => a@.
60     fromInteger         :: Integer -> a
61
62     {-# INLINE (-) #-}
63     {-# INLINE negate #-}
64     x - y               = x + negate y
65     negate x            = 0 - x
66     {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
67
68 -- | the same as @'flip' ('-')@.
69 --
70 -- Because @-@ is treated specially in the Haskell grammar,
71 -- @(-@ /e/@)@ is not a section, but an application of prefix negation.
72 -- However, @('subtract'@ /exp/@)@ is equivalent to the disallowed section.
73 {-# INLINE subtract #-}
74 subtract :: (Num a) => a -> a -> a
75 subtract x y = y - x
76 \end{code}
77
78
79 %*********************************************************
80 %*                                                      *
81 \subsection{Instances for @Int@}
82 %*                                                      *
83 %*********************************************************
84
85 \begin{code}
86 instance  Num Int  where
87     I# x + I# y = I# (x +# y)
88     I# x - I# y = I# (x -# y)
89     negate (I# x) = I# (negateInt# x)
90     I# x * I# y = I# (x *# y)
91     abs n  = if n `geInt` 0 then n else negate n
92
93     signum n | n `ltInt` 0 = negate 1
94              | n `eqInt` 0 = 0
95              | otherwise   = 1
96
97     {-# INLINE fromInteger #-}   -- Just to be sure!
98     fromInteger i = I# (integerToInt i)
99 \end{code}
100
101 %*********************************************************
102 %*                                                      *
103 \subsection{Instances for @Word@}
104 %*                                                      *
105 %*********************************************************
106
107 \begin{code}
108 instance Num Word where
109     (W# x#) + (W# y#)      = W# (x# `plusWord#` y#)
110     (W# x#) - (W# y#)      = W# (x# `minusWord#` y#)
111     (W# x#) * (W# y#)      = W# (x# `timesWord#` y#)
112     negate (W# x#)         = W# (int2Word# (negateInt# (word2Int# x#)))
113     abs x                  = x
114     signum 0               = 0
115     signum _               = 1
116     fromInteger i          = W# (integerToWord i)
117 \end{code}
118
119 %*********************************************************
120 %*                                                      *
121 \subsection{The @Integer@ instances for @Num@}
122 %*                                                      *
123 %*********************************************************
124
125 \begin{code}
126 instance  Num Integer  where
127     (+) = plusInteger
128     (-) = minusInteger
129     (*) = timesInteger
130     negate         = negateInteger
131     fromInteger x  =  x
132
133     abs = absInteger
134     signum = signumInteger
135 \end{code}
136