[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 6983e85..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 )
@@ -181,7 +187,7 @@ scanr1 _ []             =  errorEmptyList "scanr1"
 -- iterate f x == [x, f x, f (f x), ...]
 iterate :: (a -> a) -> a -> [a]
 {-# INLINE iterate #-}
-iterate f x = build (\c n -> iterateFB c f x)
+iterate f x = build (\c _n -> iterateFB c f x)
 
 iterateFB c f x = x `c` iterateFB c f (f x)
 
@@ -195,7 +201,7 @@ iterateList f x =  x : iterateList f (f x)
 -- repeat x is an infinite list, with x the value of every element.
 repeat :: a -> [a]
 {-# INLINE repeat #-}
-repeat x = build (\c n -> repeatFB c x)
+repeat x = build (\c _n -> repeatFB c x)
 
 repeatFB c x = xs where xs = x `c` xs
 repeatList x = xs where xs = x :   xs
@@ -241,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 */
@@ -429,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
@@ -456,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
@@ -526,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
@@ -541,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}