% -----------------------------------------------------------------------------
-% $Id: PrelBase.lhs,v 1.45 2001/04/14 22:28:22 qrczak Exp $
+% $Id: PrelBase.lhs,v 1.49 2001/04/29 11:01:13 qrczak Exp $
%
% (c) The University of Glasgow, 1992-2000
%
return :: a -> m a
fail :: String -> m a
- m >> k = m >>= \_ -> k
+ m >> k = m >>= \_ -> k
fail s = error s
\end{code}
-- to avoid weird names like con2tag_[]#
-instance (Eq a) => Eq [a] where
+instance (Eq a) => Eq [a] where
{-# SPECIALISE instance Eq [Char] #-}
[] == [] = True
(x:xs) == (y:ys) = x == y && xs == ys
instance (Ord a) => Ord [a] where
{-# SPECIALISE instance Ord [Char] #-}
-
compare [] [] = EQ
compare [] (_:_) = LT
compare (_:_) [] = GT
(++) = append
{-# RULES
- "++" forall xs ys. (++) xs ys = augment (\c n -> foldr c n xs) ys
+"++" forall xs ys. (++) xs ys = augment (\c n -> foldr c n xs) ys
#-}
append :: [a] -> [a] -> [a]
it here seems more direct.)
\begin{code}
-data () = ()
+data () = ()
instance Eq () where
() == () = True
-- '>' uses compare, and therefore takes two primops instead of one.
instance Eq Char where
- (C# c1) == (C# c2) = c1 `eqChar#` c2
- (C# c1) /= (C# c2) = c1 `neChar#` c2
+ (C# c1) == (C# c2) = c1 `eqChar#` c2
+ (C# c1) /= (C# c2) = c1 `neChar#` c2
instance Ord Char where
- (C# c1) > (C# c2) = c1 `gtChar#` c2
- (C# c1) >= (C# c2) = c1 `geChar#` c2
- (C# c1) <= (C# c2) = c1 `leChar#` c2
- (C# c1) < (C# c2) = c1 `ltChar#` c2
+ (C# c1) > (C# c2) = c1 `gtChar#` c2
+ (C# c1) >= (C# c2) = c1 `geChar#` c2
+ (C# c1) <= (C# c2) = c1 `leChar#` c2
+ (C# c1) < (C# c2) = c1 `ltChar#` c2
+
+{-# RULES
+"x# `eqChar#` x#" forall x#. eqChar# x# x# = True
+"x# `neChar#` x#" forall x#. neChar# x# x# = False
+"x# `gtChar#` x#" forall x#. gtChar# x# x# = False
+"x# `geChar#` x#" forall x#. geChar# x# x# = True
+"x# `leChar#` x#" forall x#. leChar# x# x# = True
+"x# `ltChar#` x#" forall x#. ltChar# x# x# = False
+ #-}
chr :: Int -> Char
-chr (I# i) | i >=# 0# && i <=# 0x10FFFF# = C# (chr# i)
- | otherwise = error "Prelude.chr: bad argument"
+chr (I# i#) | int2Word# i# `leWord#` int2Word# 0x10FFFF# = C# (chr# i#)
+ | otherwise = error "Prelude.chr: bad argument"
unsafeChr :: Int -> Char
-unsafeChr (I# i) = C# (chr# i)
+unsafeChr (I# i#) = C# (chr# i#)
ord :: Char -> Int
-ord (C# c) = I# (ord# c)
+ord (C# c#) = I# (ord# c#)
\end{code}
String equality is used when desugaring pattern-matches against strings.
instance Ord Int where
compare = compareInt
-
- (<) = ltInt
- (<=) = leInt
- (>=) = geInt
- (>) = gtInt
+ (<) = ltInt
+ (<=) = leInt
+ (>=) = geInt
+ (>) = gtInt
compareInt :: Int -> Int -> Ordering
-(I# x) `compareInt` (I# y) = compareInt# x y
+(I# x#) `compareInt` (I# y#) = compareInt# x# y#
compareInt# :: Int# -> Int# -> Ordering
compareInt# x# y#
- | x# <# y# = LT
- | x# ==# y# = EQ
- | otherwise = GT
+ | x# <# y# = LT
+ | x# ==# y# = EQ
+ | otherwise = GT
\end{code}
(I# x) `divInt` (I# y) = I# (x `divInt#` y)
(I# x) `modInt` (I# y) = I# (x `modInt#` y)
+{-# RULES
+"x# +# 0#" forall x#. (+#) x# 0# = x#
+"0# +# x#" forall x#. (+#) 0# x# = x#
+"x# -# 0#" forall x#. (-#) x# 0# = x#
+"x# -# x#" forall x#. (-#) x# x# = 0#
+"x# *# 0#" forall x#. (*#) x# 0# = 0#
+"0# *# x#" forall x#. (*#) 0# x# = 0#
+"x# *# 1#" forall x#. (*#) x# 1# = x#
+"1# *# x#" forall x#. (*#) 1# x# = x#
+ #-}
+
gcdInt (I# a) (I# b) = g a b
where g 0# 0# = error "PrelBase.gcdInt: gcd 0 0 is undefined"
g 0# _ = I# absB
(I# x) `ltInt` (I# y) = x <# y
(I# x) `leInt` (I# y) = x <=# y
+{-# RULES
+"x# ># x#" forall x#. (>#) x# x# = False
+"x# >=# x#" forall x#. (>=#) x# x# = True
+"x# ==# x#" forall x#. (==#) x# x# = True
+"x# /=# x#" forall x#. (/=#) x# x# = False
+"x# <# x#" forall x#. (<#) x# x# = False
+"x# <=# x#" forall x#. (<=#) x# x# = True
+ #-}
+
#if WORD_SIZE_IN_BYTES == 4
{-# RULES
"intToInt32#" forall x#. intToInt32# x# = x#