[project @ 1999-07-14 08:37:57 by simonmar]

[ghc-hetmet.git] / ghc / lib / std / PrelList.lhs

diff --git a/ghc/lib/std/PrelList.lhs b/ghc/lib/std/PrelList.lhs
index 2e4a076..b1a0b7c 100644 (file)
--- a/ghc/lib/std/PrelList.lhs
+++ b/ghc/lib/std/PrelList.lhs
@@ -22,10 +22,16 @@ module PrelList (
    maximum, minimum, concatMap,
    zip, zip3, zipWith, zipWith3, unzip, unzip3,
 
+#ifdef USE_REPORT_PRELUDE
+
+#else
+
    -- non-standard, but hidden when creating the Prelude
    -- export list.
    takeUInt_append
 
+#endif
+
  ) where
 
 import {-# SOURCE #-} PrelErr ( error )
@@ -51,7 +57,18 @@ infix  4 `elem`, `notElem`
 
 head                    :: [a] -> a
 head (x:_)              =  x
-head []                 =  errorEmptyList "head"
+head []                 =  badHead
+
+badHead = errorEmptyList "head"
+
+-- This rule is useful in cases like 
+--     head [y | (x,y) <- ps, x==t]
+{-# RULES
+"head/build"   forall g::forall b.(Bool->b->b)->b->b . 
+               head (build g) = g (\x _ -> x) badHead
+"head/augment" forall xs, g::forall b. (a->b->b) -> b -> b . 
+               head (augment g xs) = g (\x _ -> x) (head xs)
+ #-}
 
 tail                    :: [a] -> [a]
 tail (_:xs)             =  xs
@@ -168,12 +185,30 @@ scanr1 _ []             =  errorEmptyList "scanr1"
 
 -- iterate f x returns an infinite list of repeated applications of f to x:
 -- iterate f x == [x, f x, f (f x), ...]
-iterate                 :: (a -> a) -> a -> [a]
-iterate f x             =  x : iterate f (f x)
+iterate :: (a -> a) -> a -> [a]
+{-# INLINE iterate #-}
+iterate f x = build (\c _n -> iterateFB c f x)
+
+iterateFB c f x = x `c` iterateFB c f (f x)
+
+iterateList f x =  x : iterateList f (f x)
+
+{-# RULES
+"iterate"      iterateFB (:) = iterateList
+ #-}
+
 
 -- repeat x is an infinite list, with x the value of every element.
-repeat                  :: a -> [a]
-repeat x                =  xs where xs = x:xs
+repeat :: a -> [a]
+{-# INLINE repeat #-}
+repeat x = build (\c _n -> repeatFB c x)
+
+repeatFB c x = xs where xs = x `c` xs
+repeatList x = xs where xs = x :   xs
+
+{-# RULES
+"repeat"       repeatFB (:) = repeatList
+ #-}
 
 -- replicate n x is a list of length n with x the value of every element
 replicate               :: Int -> a -> [a]
@@ -212,20 +247,20 @@ dropWhile p xs@(x:xs')
 take                   :: Int -> [a] -> [a]
 take 0 _               =  []
 take _ []              =  []
-take n (x:xs) | n > 0  =  x : take (n-1) xs
+take n (x:xs) | n > 0  =  x : take (minusInt n 1) xs
 take _     _           =  errorNegativeIdx "take"
 
 drop                   :: Int -> [a] -> [a]
 drop 0 xs              =  xs
 drop _ []              =  []
-drop n (_:xs) | n > 0  =  drop (n-1) xs
+drop n (_:xs) | n > 0  =  drop (minusInt n 1) xs
 drop _     _           =  errorNegativeIdx "drop"
 
 
 splitAt                   :: Int -> [a] -> ([a],[a])
 splitAt 0 xs              =  ([],xs)
 splitAt _ []              =  ([],[])
-splitAt n (x:xs) | n > 0  =  (x:xs',xs'') where (xs',xs'') = splitAt (n-1) xs
+splitAt n (x:xs) | n > 0  =  (x:xs',xs'') where (xs',xs'') = splitAt (minusInt n 1) xs
 splitAt _     _           =  errorNegativeIdx "splitAt"
 
 #else /* hack away */
@@ -347,9 +382,9 @@ all _ []    =  True
 all p (x:xs)   =  p x && all p xs
 {-# RULES
 "any/build"    forall p, g::forall b.(a->b->b)->b->b . 
-               any p (build g) = g ((&&) . p) True
+               any p (build g) = g ((||) . p) False
 "all/build"    forall p, g::forall b.(a->b->b)->b->b . 
-               all p (build g) = g ((||) . p) False
+               all p (build g) = g ((&&) . p) True
  #-}
 #endif
 
@@ -400,7 +435,7 @@ concat = foldr (++) []
 (!!)                    :: [a] -> Int -> a
 #ifdef USE_REPORT_PRELUDE
 (x:_)  !! 0             =  x
-(_:xs) !! n | n > 0     =  xs !! (n-1)
+(_:xs) !! n | n > 0     =  xs !! (minusInt n 1)
 (_:_)  !! _             =  error "Prelude.(!!): negative index"
 []     !! _             =  error "Prelude.(!!): index too large"
 #else
@@ -427,15 +462,15 @@ xs !! (I# n) | n <# 0#   =  error "Prelude.(!!): negative index\n"
 %*********************************************************
 
 \begin{code}
-foldr2 k z []    ys     = z
-foldr2 k z xs    []     = z
+foldr2 _k z []           _ys    = z
+foldr2 _k z _xs   []    = z
 foldr2 k z (x:xs) (y:ys) = k x y (foldr2 k z xs ys)
 
-foldr2_left k z x r []     = z
-foldr2_left k z x r (y:ys) = k x y (r ys)
+foldr2_left _k  z _x _r []     = z
+foldr2_left  k _z  x  r (y:ys) = k x y (r ys)
 
-foldr2_right k z y r []     = z
-foldr2_right k z y r (x:xs) = k x y (r xs)
+foldr2_right _k z  _y _r []     = z
+foldr2_right  k _z  y  r (x:xs) = k x y (r xs)
 
 -- foldr2 k z xs ys = foldr (foldr2_left k z)  (\_ -> z) xs ys
 -- foldr2 k z xs ys = foldr (foldr2_right k z) (\_ -> z) ys xs
@@ -497,7 +532,7 @@ zipWithFB c f x y r = (x `f` y) `c` r
 
 zipWithList                 :: (a->b->c) -> [a] -> [b] -> [c]
 zipWithList f (a:as) (b:bs) = f a b : zipWithList f as bs
-zipWithList f _      _      = []
+zipWithList _ _      _      = []
 
 {-# RULES
 "zipWithList"  forall f. foldr2 (zipWithFB (:) f) [] = zipWithList f
@@ -512,9 +547,11 @@ zipWith3 _ _ _ _        =  []
 
 -- unzip transforms a list of pairs into a pair of lists.  
 unzip    :: [(a,b)] -> ([a],[b])
+{-# INLINE unzip #-}
 unzip    =  foldr (\(a,b) ~(as,bs) -> (a:as,b:bs)) ([],[])
 
 unzip3   :: [(a,b,c)] -> ([a],[b],[c])
+{-# INLINE unzip3 #-}
 unzip3   =  foldr (\(a,b,c) ~(as,bs,cs) -> (a:as,b:bs,c:cs))
                   ([],[],[])
 \end{code}