X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Flib%2Fstd%2FPrelList.lhs;h=1ea90d6d130b8a1cba49eef5419d13b24d72089d;hb=d3058014b75ef30cc1535dcc6abcf073b3170697;hp=b1a0b7cf1c7a67a6769eb87bb625e014861bb047;hpb=cc4d138db7ea5b8bbd4767f665158fbf9bb97611;p=ghc-hetmet.git

diff --git a/ghc/lib/std/PrelList.lhs b/ghc/lib/std/PrelList.lhs
index b1a0b7c..1ea90d6 100644
--- a/ghc/lib/std/PrelList.lhs
+++ b/ghc/lib/std/PrelList.lhs
@@ -64,9 +64,9 @@ 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"	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"	forall xs (g::forall b. (a->b->b) -> b -> b) . 
 		head (augment g xs) = g (\x _ -> x) (head xs)
  #-}
 
@@ -118,14 +118,14 @@ length l                =  len l 0#
 -- elements that satisfy the predicate; i.e.,
 -- filter p xs = [ x | x <- xs, p x]
 filter :: (a -> Bool) -> [a] -> [a]
-{-# INLINE filter #-}
-filter p xs = build (\c n -> foldr (filterFB c p) n xs)
+filter = filterList
 
 filterFB c p x r | p x       = x `c` r
 		 | otherwise = r
 
 {-# RULES
-"filterFB"	forall c,p,q.	filterFB (filterFB c p) q = filterFB c (\x -> p x && q x)
+"filter"	forall p xs.	filter p xs = build (\c n -> foldr (filterFB c p) n xs)
+"filterFB"	forall c p q.	filterFB (filterFB c p) q = filterFB c (\x -> p x && q x)
 "filterList" 	forall p.	foldr (filterFB (:) p) [] = filterList p
  #-}
 
@@ -186,28 +186,28 @@ 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]
-{-# INLINE iterate #-}
-iterate f x = build (\c _n -> iterateFB c f x)
+iterate = iterateList
 
 iterateFB c f x = x `c` iterateFB c f (f x)
 
 iterateList f x =  x : iterateList f (f x)
 
 {-# RULES
-"iterate" 	iterateFB (:) = iterateList
+"iterate"	forall f x.	iterate f x = build (\c _n -> iterateFB c f x)
+"iterateFB" 			iterateFB (:) = iterateList
  #-}
 
 
 -- 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 = repeatList
 
 repeatFB c x = xs where xs = x `c` xs
 repeatList x = xs where xs = x :   xs
 
 {-# RULES
-"repeat" 	repeatFB (:) = repeatList
+"repeat"	forall x. repeat x	= build (\c _n -> repeatFB c x)
+"repeatFB" 		  repeatFB (:)	= repeatList
  #-}
 
 -- replicate n x is a list of length n with x the value of every element
@@ -361,9 +361,9 @@ or []		=  False
 or (x:xs)	=  x || or xs
 
 {-# RULES
-"and/build"	forall g::forall b.(Bool->b->b)->b->b . 
+"and/build"	forall (g::forall b.(Bool->b->b)->b->b) . 
 		and (build g) = g (&&) True
-"or/build"	forall g::forall b.(Bool->b->b)->b->b . 
+"or/build"	forall (g::forall b.(Bool->b->b)->b->b) . 
 		or (build g) = g (||) False
  #-}
 #endif
@@ -381,9 +381,9 @@ any p (x:xs)	= p x || any p xs
 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/build"	forall p (g::forall b.(a->b->b)->b->b) . 
 		any p (build g) = g ((||) . p) False
-"all/build"	forall p, g::forall b.(a->b->b)->b->b . 
+"all/build"	forall p (g::forall b.(a->b->b)->b->b) . 
 		all p (build g) = g ((&&) . p) True
  #-}
 #endif
@@ -475,10 +475,10 @@ 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
 {-# RULES
-"foldr2/left"	forall k,z,ys,g::forall b.(a->b->b)->b->b . 
+"foldr2/left"	forall k z ys (g::forall b.(a->b->b)->b->b) . 
 		  foldr2 k z (build g) ys = g (foldr2_left  k z) (\_ -> z) ys
 
-"foldr2/right"	forall k,z,xs,g::forall b.(a->b->b)->b->b . 
+"foldr2/right"	forall k z xs (g::forall b.(a->b->b)->b->b) . 
 		  foldr2 k z xs (build g) = g (foldr2_right k z) (\_ -> z) xs
  #-}
 \end{code}
@@ -491,8 +491,7 @@ tuples are in the List library
 \begin{code}
 ----------------------------------------------
 zip :: [a] -> [b] -> [(a,b)]
-{-# INLINE zip #-}
-zip xs ys = build (\c n -> foldr2 (zipFB c) n xs ys)
+zip = zipList
 
 zipFB c x y r = (x,y) `c` r
 
@@ -502,7 +501,8 @@ zipList (a:as) (b:bs) = (a,b) : zipList as bs
 zipList _      _      = []
 
 {-# RULES
-"zipList"	foldr2 (zipFB (:)) [] = zipList
+"zip"		forall xs ys. zip xs ys	= build (\c n -> foldr2 (zipFB c) n xs ys)
+"zipList"	foldr2 (zipFB (:)) []   = zipList
  #-}
 \end{code}
 
@@ -525,8 +525,8 @@ zip3 _      _      _      = []
 \begin{code}
 ----------------------------------------------
 zipWith :: (a->b->c) -> [a]->[b]->[c]
-{-# INLINE zipWith #-}
-zipWith f xs ys = build (\c n -> foldr2 (zipWithFB c f) n xs ys)
+zipWith = zipWithList
+
 
 zipWithFB c f x y r = (x `f` y) `c` r
 
@@ -535,7 +535,8 @@ zipWithList f (a:as) (b:bs) = f a b : zipWithList f as bs
 zipWithList _ _      _      = []
 
 {-# RULES
-"zipWithList"	forall f. foldr2 (zipWithFB (:) f) [] = zipWithList f
+"zipWith"	forall f xs ys.	zipWith f xs ys = build (\c n -> foldr2 (zipWithFB c f) n xs ys)
+"zipWithList"	forall f. 	foldr2 (zipWithFB (:) f) [] = zipWithList f
   #-}
 \end{code}