use hierarchical module names
[haskell-report.git] / report / Prelude.hs
index 08ad7c0..bb87b3c 100644 (file)
@@ -5,10 +5,15 @@ module Prelude (
     Either(Left, Right),
     Ordering(LT, EQ, GT),
     Char, String, Int, Integer, Float, Double, Rational, IO,
+
+--      These built-in types are defined in the Prelude, but
+--      are denoted by built-in syntax, and cannot legally
+--      appear in an export list.
 --  List type: []((:), [])
---  Tuple types: (,), (,,), etc.
---  Trivial type: ()
+--  Tuple types: (,)((,)), (,,)((,,)), etc.
+--  Trivial type: ()(())
 --  Functions: (->)
+
     Eq((==), (/=)),
     Ord(compare, (<), (<=), (>=), (>), max, min),
     Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
@@ -36,17 +41,22 @@ module Prelude (
     seq, ($!)
   ) where
 
-import PreludeBuiltin  -- Contains all `prim' values
+import PreludeBuiltin                      -- Contains all `prim' values
+import UnicodePrims( primUnicodeMaxChar )  -- Unicode primitives
 import PreludeList
 import PreludeText
 import PreludeIO
-import Ratio( Rational )
+import Data.Ratio( Rational )
 
 infixr 9  .
 infixr 8  ^, ^^, **
 infixl 7  *, /, `quot`, `rem`, `div`, `mod`
 infixl 6  +, -
-infixr 5  :
+
+-- The (:) operator is built-in syntax, and cannot legally be given
+-- a fixity declaration; but its fixity is given by:
+--   infixr 5  :
+
 infix  4  ==, /=, <, <=, >=, >
 infixr 3  &&
 infixr 2  ||
@@ -59,15 +69,15 @@ infixr 0  $, $!, `seq`
 -- Equality and Ordered classes
 
 class  Eq a  where
-    (==), (/=)       :: a -> a -> Bool
+    (==), (/=) :: a -> a -> Bool
 
         -- Minimal complete definition:
         --      (==) or (/=)
-    x /= y           =  not (x == y)
-    x == y           =  not (x /= y)
+    x /= y     =  not (x == y)
+    x == y     =  not (x /= y)
 
 class  (Eq a) => Ord a  where
-    compare                     :: a -> a -> Ordering
+    compare              :: a -> a -> Ordering
     (<), (<=), (>=), (>) :: a -> a -> Bool
     max, min             :: a -> a -> a
 
@@ -86,10 +96,10 @@ class  (Eq a) => Ord a  where
 
 -- note that (min x y, max x y) = (x,y) or (y,x)
     max x y 
-         | x >= y    =  x
-         | otherwise =  y
+         | x <= y    =  y
+         | otherwise =  x
     min x y
-         | x <  y    =  x
+         | x <= y    =  x
          | otherwise =  y
 
 -- Enumeration and Bounded classes
@@ -105,11 +115,15 @@ class  Enum a  where
 
         -- Minimal complete definition:
         --      toEnum, fromEnum
+       --
+       -- NOTE: these default methods only make sense for types
+       --       that map injectively into Int using fromEnum
+       --       and toEnum.
     succ             =  toEnum . (+1) . fromEnum
     pred             =  toEnum . (subtract 1) . fromEnum
     enumFrom x       =  map toEnum [fromEnum x ..]
     enumFromTo x y   =  map toEnum [fromEnum x .. fromEnum y]
-    enumFromThen x y =  map toEnum [fromEnum x, fromEnum y, ..]
+    enumFromThen x y =  map toEnum [fromEnum x, fromEnum y ..]
     enumFromThenTo x y z = 
                         map toEnum [fromEnum x, fromEnum y .. fromEnum z]
 
@@ -169,6 +183,7 @@ class  (Fractional a) => Floating a  where
 
         -- Minimal complete definition:
         --      pi, exp, log, sin, cos, sinh, cosh
+        --      asin, acos, atan
         --      asinh, acosh, atanh
     x ** y           =  exp (log x * y)
     logBase x y      =  log y / log x
@@ -313,11 +328,10 @@ f =<< x          =  x >>= f
 -- Trivial type
 
 data  ()  =  ()  deriving (Eq, Ord, Enum, Bounded)
+       -- Not legal Haskell; for illustration only
 
 -- Function type
 
-data a -> b  -- No constructor for functions is exported.
-
 -- identity function
 id               :: a -> a
 id x             =  x
@@ -366,7 +380,7 @@ otherwise        =  True
 
 -- Character type
 
-data Char = ... 'a' | 'b' ... -- 2^16 unicode values
+data Char = ... 'a' | 'b' ... -- Unicode values
 
 instance  Eq Char  where
     c == c'          =  fromEnum c == fromEnum c'
@@ -380,12 +394,12 @@ instance  Enum Char  where
     enumFrom c        = map toEnum [fromEnum c .. fromEnum (maxBound::Char)]
     enumFromThen c c' = map toEnum [fromEnum c, fromEnum c' .. fromEnum lastChar]
                       where lastChar :: Char
-                               lastChar | c' < c    = minBound
-                                        | otherwise = maxBound
+                            lastChar | c' < c    = minBound
+                                     | otherwise = maxBound
 
 instance  Bounded Char  where
-    minBound            =  '\0'
-    maxBound            =  '\xffff'
+    minBound  =  '\0'
+    maxBound  =  primUnicodeMaxChar
 
 type  String = [Char]
 
@@ -418,7 +432,7 @@ either f g (Right y) =  g y
 
 -- IO type
 
-data  IO a  -- abstract
+data IO a = ...        -- abstract
 
 instance  Functor IO where
    fmap f x           =  x >>= (return . f)
@@ -426,8 +440,6 @@ instance  Functor IO where
 instance Monad IO where
    (>>=)  = ...
    return = ...
-
-   m >> k = m >>= \_ -> k
    fail s = ioError (userError s)
 
 -- Ordering type
@@ -513,14 +525,13 @@ numericEnumFromThen n m =  iterate (+(m-n)) n
 numericEnumFromTo n m   =  takeWhile (<= m+1/2) (numericEnumFrom n)
 numericEnumFromThenTo n n' m = takeWhile p (numericEnumFromThen n n')
                              where
-                               p | n' > n    = (<= m + (n'-n)/2)
+                               p | n' >= n   = (<= m + (n'-n)/2)
                                  | otherwise = (>= m + (n'-n)/2)
 
 -- Lists
 
--- This data declaration is not legal Haskell
--- but it indicates the idea
 data  [a]  =  [] | a : [a]  deriving (Eq, Ord)
+       -- Not legal Haskell; for illustration only
 
 instance Functor [] where
     fmap = map
@@ -534,7 +545,7 @@ instance  Monad []  where
 
 data  (a,b)   =  (a,b)    deriving (Eq, Ord, Bounded)
 data  (a,b,c) =  (a,b,c)  deriving (Eq, Ord, Bounded)
-
+       -- Not legal Haskell; for illustration only
 
 -- component projections for pairs:
 -- (NB: not provided for triples, quadruples, etc.)