% ------------------------------------------------------------------------------
-% $Id: PrelList.lhs,v 1.26 2001/08/28 15:07:58 simonmar Exp $
+% $Id: PrelList.lhs,v 1.28 2001/09/26 15:12:37 simonpj Exp $
%
% (c) The University of Glasgow, 1994-2000
%
-- filter, applied to a predicate and a list, returns the list of those
-- elements that satisfy the predicate; i.e.,
-- filter p xs = [ x | x <- xs, p x]
+{-# NOINLINE [1] filter #-}
filter :: (a -> Bool) -> [a] -> [a]
filter = filterList
+{-# INLINE [0] filter #-}
filterFB c p x r | p x = x `c` r
| otherwise = r
[] -> []
x:xs -> scanl f (f q x) xs)
-scanl1 :: (a -> a -> a) -> [a] -> [a]
-scanl1 f (x:xs) = scanl f x xs
-scanl1 _ [] = errorEmptyList "scanl1"
+scanl1 :: (a -> a -> a) -> [a] -> [a]
+scanl1 f (x:xs) = scanl f x xs
+scanl1 _ [] = []
-- foldr, foldr1, scanr, and scanr1 are the right-to-left duals of the
-- above functions.
where qs@(q:_) = scanr f q0 xs
scanr1 :: (a -> a -> a) -> [a] -> [a]
-scanr1 _ [x] = [x]
-scanr1 f (x:xs) = f x q : qs
+scanr1 f [] = []
+scanr1 f [x] = [x]
+scanr1 f (x:xs) = f x q : qs
where qs@(q:_) = scanr1 f xs
-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]
+{-# NOINLINE [1] iterate #-}
iterate = iterateList
iterateFB c f x = x `c` iterateFB c f (f x)
-- repeat x is an infinite list, with x the value of every element.
repeat :: a -> [a]
+{-# NOINLINE [1] repeat #-}
repeat = repeatList
+{-# INLINE [0] repeatFB #-}
repeatFB c x = xs where xs = x `c` xs
+
repeatList x = xs where xs = x : xs
{-# RULES
\begin{code}
----------------------------------------------
zip :: [a] -> [b] -> [(a,b)]
+{-# NOINLINE [1] zip #-}
zip = zipList
+{-# INLINE [0] zipFB #-}
zipFB c x y r = (x,y) `c` r
\begin{code}
----------------------------------------------
zipWith :: (a->b->c) -> [a]->[b]->[c]
+{-# NOINLINE [1] zipWith #-}
zipWith = zipWithList
-
+{-# INLINE [0] zipWithFB #-}
zipWithFB c f x y r = (x `f` y) `c` r
zipWithList :: (a->b->c) -> [a] -> [b] -> [c]