X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=ghc%2Fcompiler%2Futils%2FMaybes.lhs;h=961da188e820949f48bcc28ab77ba59e11043bd1;hb=99655406c82829dfc9663fc545a0e134c49fb79f;hp=b29dd9c56454180f445f305127474df36e0c90c2;hpb=fd85674c9539d4f182e94526e4fbf0d0e32a8271;p=ghc-hetmet.git

diff --git a/ghc/compiler/utils/Maybes.lhs b/ghc/compiler/utils/Maybes.lhs
index b29dd9c..961da18 100644
--- a/ghc/compiler/utils/Maybes.lhs
+++ b/ghc/compiler/utils/Maybes.lhs
@@ -1,42 +1,34 @@
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
 %
 \section[Maybes]{The `Maybe' types and associated utility functions}
 
 \begin{code}
-#include "HsVersions.h"
-
 module Maybes (
---	Maybe(..), -- no, it's in 1.3
+	module Maybe,		-- Re-export all of Maybe
+
 	MaybeErr(..),
 
-	mapMaybe,
+	orElse, 
+	mapCatMaybes,
 	allMaybes,
 	firstJust,
 	expectJust,
 	maybeToBool,
 
-	assocMaybe,
-	mkLookupFun, mkLookupFunDef,
+	thenMaybe, seqMaybe, returnMaybe, failMaybe, 
+
+	thenMaB, returnMaB, failMaB
 
-	failMaB,
-	failMaybe,
-	seqMaybe,
-	returnMaB,
-	returnMaybe,
-	thenMaB,
-	catMaybes
     ) where
 
-CHK_Ubiq()		-- debugging consistency check
-import Unique  (Unique)	-- only for specialising
+#include "HsVersions.h"
 
-#if __GLASGOW_HASKELL__ >= 204
-import Maybe( catMaybes, mapMaybe )
-#endif
+import Maybe
 
-\end{code}
 
+infixr 4 `orElse`
+\end{code}
 
 %************************************************************************
 %*									*
@@ -63,19 +55,6 @@ allMaybes (Just x  : ms) = case (allMaybes ms) of
 			     Nothing -> Nothing
 			     Just xs -> Just (x:xs)
 
-#if __GLASGOW_HASKELL__ < 204
-	-- After 2.04 we get these from the library Maybe
-catMaybes :: [Maybe a] -> [a]
-catMaybes []		    = []
-catMaybes (Nothing : xs)   = catMaybes xs
-catMaybes (Just x : xs)	   = (x : catMaybes xs)
-
-mapMaybe :: (a -> Maybe b) -> [a] -> [b]
-mapMaybe f [] = []
-mapMaybe f (x:xs) = case f x of
-			Just y  -> y : mapMaybe f xs
-			Nothing -> mapMaybe f xs
-#endif
 \end{code}
 
 @firstJust@ takes a list of @Maybes@ and returns the
@@ -89,20 +68,20 @@ firstJust (Nothing : ms) = firstJust ms
 \end{code}
 
 \begin{code}
-findJust :: (a -> Maybe b) -> [a] -> Maybe b
-findJust f []	  = Nothing
-findJust f (a:as) = case f a of
-		      Nothing -> findJust f as
-		      b	 -> b
-\end{code}
-
-\begin{code}
 expectJust :: String -> Maybe a -> a
 {-# INLINE expectJust #-}
 expectJust err (Just x) = x
 expectJust err Nothing  = error ("expectJust " ++ err)
 \end{code}
 
+\begin{code}
+mapCatMaybes :: (a -> Maybe b) -> [a] -> [b]
+mapCatMaybes f [] = []
+mapCatMaybes f (x:xs) = case f x of
+			  Just y  -> y : mapCatMaybes f xs
+			  Nothing -> mapCatMaybes f xs
+\end{code}
+
 The Maybe monad
 ~~~~~~~~~~~~~~~
 \begin{code}
@@ -110,62 +89,22 @@ seqMaybe :: Maybe a -> Maybe a -> Maybe a
 seqMaybe (Just x) _  = Just x
 seqMaybe Nothing  my = my
 
+thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
+thenMaybe ma mb = case ma of
+		    Just x  -> mb x
+		    Nothing -> Nothing
+
 returnMaybe :: a -> Maybe a
 returnMaybe = Just
 
 failMaybe :: Maybe a
 failMaybe = Nothing
-\end{code}
-
-Lookup functions
-~~~~~~~~~~~~~~~~
-
-@assocMaybe@ looks up in an assocation list, returning
-@Nothing@ if it fails.
 
-\begin{code}
-assocMaybe :: (Eq a) => [(a,b)] -> a -> Maybe b
-
-assocMaybe alist key
-  = lookup alist
-  where
-    lookup []		  = Nothing
-    lookup ((tv,ty):rest) = if key == tv then Just ty else lookup rest
-
-{-# SPECIALIZE assocMaybe
-	:: [(FAST_STRING,   b)] -> FAST_STRING -> Maybe b
-	 , [(Int,           b)] -> Int         -> Maybe b
-	 , [(Unique,        b)] -> Unique      -> Maybe b
-  #-}
+orElse :: Maybe a -> a -> a
+(Just x) `orElse` y = x
+Nothing  `orElse` y = y
 \end{code}
 
-@mkLookupFun eq alist@ is a function which looks up
-its argument in the association list @alist@, returning a Maybe type.
-@mkLookupFunDef@ is similar except that it is given a value to return
-on failure.
-
-\begin{code}
-mkLookupFun :: (key -> key -> Bool)	-- Equality predicate
-	    -> [(key,val)] 		-- The assoc list
-	    -> key 			-- The key
-	    -> Maybe val		-- The corresponding value
-
-mkLookupFun eq alist s
-  = case [a | (s',a) <- alist, s' `eq` s] of
-      []    -> Nothing
-      (a:_) -> Just a
-
-mkLookupFunDef :: (key -> key -> Bool)	-- Equality predicate
-	       -> [(key,val)] 		-- The assoc list
-	       -> val 			-- Value to return on failure
-	       -> key 			-- The key
-	       -> val			-- The corresponding value
-
-mkLookupFunDef eq alist deflt s
-  = case [a | (s',a) <- alist, s' `eq` s] of
-      []    -> deflt
-      (a:_) -> a
-\end{code}
 
 %************************************************************************
 %*									*
@@ -190,3 +129,4 @@ returnMaB v = Succeeded v
 failMaB :: err -> MaybeErr val err
 failMaB e = Failed e
 \end{code}
+