[project @ 2001-08-04 06:19:54 by ken]

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

diff --git a/ghc/lib/std/List.lhs b/ghc/lib/std/List.lhs
index 990b040..93640a4 100644 (file)
--- a/ghc/lib/std/List.lhs
+++ b/ghc/lib/std/List.lhs
@@ -1,15 +1,20 @@
+% -----------------------------------------------------------------------------
+% $Id: List.lhs,v 1.12 2001/06/25 13:13:58 simonpj Exp $
 %
-% (c) The AQUA Project, Glasgow University, 1994-1999
+% (c) The University of Glasgow, 1994-2000
 %
 
-\section[List]{Module @Lhar@}
+\section[List]{Module @List@}
 
 \begin{code}
 module List 
    ( 
+#ifndef __HUGS__
      []((:), [])
+   , 
+#endif
 
-   , elemIndex        -- :: (Eq a) => a -> [a] -> Maybe Int
+      elemIndex               -- :: (Eq a) => a -> [a] -> Maybe Int
    , elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
 
    , find             -- :: (a -> Bool) -> [a] -> Maybe a
@@ -62,7 +67,7 @@ module List
    , genericIndex      -- :: (Integral a) => [b] -> a -> b
    , genericReplicate  -- :: (Integral a) => a -> b -> [b]
    
-   , unfoldr           -- :: (a -> Maybe (b,a)) -> a -> (a,[b])
+   , unfoldr           -- :: (b -> Maybe (a, b)) -> b -> [a]
 
    , zip4, zip5, zip6, zip7
    , zipWith4, zipWith5, zipWith6, zipWith7
@@ -128,10 +133,14 @@ module List
 
 import Prelude
 import Maybe   ( listToMaybe )
+
+#ifndef __HUGS__
+import PrelShow        ( lines, words, unlines, unwords )
 import PrelBase        ( Int(..), map, (++) )
 import PrelGHC ( (+#) )
+#endif
 
-infix 5 \\
+infix 5 \\ 
 \end{code}
 
 %*********************************************************
@@ -158,13 +167,17 @@ findIndices      :: (a -> Bool) -> [a] -> [Int]
 #ifdef USE_REPORT_PRELUDE
 findIndices p xs = [ i | (x,i) <- zip xs [0..], p x]
 #else
+#ifdef __HUGS__
+findIndices p xs = [ i | (x,i) <- zip xs [0..], p x]
+#else 
 -- Efficient definition
 findIndices p ls = loop 0# ls
                 where
                   loop _ [] = []
                   loop n (x:xs) | p x       = I# n : loop (n +# 1#) xs
                                 | otherwise = loop (n +# 1#) xs
-#endif
+#endif  /* __HUGS__ */
+#endif  /* USE_REPORT_PRELUDE */
 
 isPrefixOf              :: (Eq a) => [a] -> [a] -> Bool
 isPrefixOf [] _         =  True
@@ -180,12 +193,12 @@ nub                     :: (Eq a) => [a] -> [a]
 nub                     =  nubBy (==)
 #else
 -- stolen from HBC
-nub l                   = nub' l []
+nub l                   = nub' l []            -- '
   where
-    nub' [] _          = []
-    nub' (x:xs) ls     
-       | x `elem` ls   = nub' xs ls
-       | otherwise     = x : nub' xs (x:ls)
+    nub' [] _          = []                    -- '
+    nub' (x:xs) ls                             -- '
+       | x `elem` ls   = nub' xs ls            -- '
+       | otherwise     = x : nub' xs (x:ls)    -- '
 #endif
 
 nubBy                  :: (a -> a -> Bool) -> [a] -> [a]
@@ -196,14 +209,18 @@ nubBy eq (x:xs)         =  x : nubBy eq (filter (\ y -> not (eq x y)) xs)
 nubBy eq l              = nubBy' l []
   where
     nubBy' [] _                = []
-    nubBy' (x:xs) ls
-       | elemBy eq x ls = nubBy' xs ls 
-       | otherwise     = x : nubBy' xs (x:ls)
-
---not exported:
-elemBy :: (a -> a -> Bool) -> a -> [a] -> Bool
-elemBy _  _ []         =  False
-elemBy eq x (y:ys)     =  x `eq` y || elemBy eq x ys
+    nubBy' (y:ys) xs
+       | elem_by eq y xs = nubBy' ys xs 
+       | otherwise      = y : nubBy' ys (y:xs)
+
+-- Not exported:
+-- Note that we keep the call to `eq` with arguments in the
+-- same order as in the reference implementation
+-- 'xs' is the list of things we've seen so far, 
+-- 'y' is the potential new element
+elem_by :: (a -> a -> Bool) -> a -> [a] -> Bool
+elem_by _  _ []                =  False
+elem_by eq y (x:xs)    =  x `eq` y || elem_by eq y xs
 #endif
 
 
@@ -252,9 +269,11 @@ transpose ((x:xs) : xss) = (x : [h | (h:t) <- xss]) : transpose (xs : [ t | (h:t
 -- predicate, respectively; i,e,,
 -- partition p xs == (filter p xs, filter (not . p) xs).
 partition              :: (a -> Bool) -> [a] -> ([a],[a])
-partition p xs         =  foldr select ([],[]) xs
-                          where select x (ts,fs) | p x       = (x:ts,fs)
-                                                  | otherwise = (ts, x:fs)
+{-# INLINE partition #-}
+partition p xs = foldr (select p) ([],[]) xs
+
+select p x (ts,fs) | p x       = (x:ts,fs)
+                   | otherwise = (ts, x:fs)
 \end{code}
 
 @mapAccumL@ behaves like a combination