[project @ 2000-03-23 17:45:17 by simonpj]

[ghc-hetmet.git] / ghc / compiler / utils / Maybes.lhs

diff --git a/ghc/compiler/utils/Maybes.lhs b/ghc/compiler/utils/Maybes.lhs
index c40ffb2..6dd9251 100644 (file)
--- a/ghc/compiler/utils/Maybes.lhs
+++ b/ghc/compiler/utils/Maybes.lhs
@@ -1,19 +1,16 @@
 %
-% (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}
-#if defined(COMPILING_GHC)
-#include "HsVersions.h"
-#endif
-
 module Maybes (
---     Maybe(..), -- no, it's in 1.3
+       Maybe2(..), Maybe3(..),
        MaybeErr(..),
 
+       orElse, 
+       mapMaybe,
        allMaybes,
-       catMaybes,
        firstJust,
        expectJust,
        maybeToBool,
@@ -26,20 +23,28 @@ module Maybes (
        seqMaybe,
        returnMaB,
        returnMaybe,
-       thenMaB
-
-#if ! defined(COMPILING_GHC)
-       , findJust
-       , foldlMaybeErrs
-       , listMaybeErrs
-#endif
+       thenMaB,
+       catMaybes
     ) where
 
-#if defined(COMPILING_GHC)
+#include "HsVersions.h"
+
+import Maybe( catMaybes, mapMaybe )
 
-CHK_Ubiq() -- debugging consistency check
 
-#endif
+infixr 4 `orElse`
+\end{code}
+
+
+%************************************************************************
+%*                                                                     *
+\subsection[Maybe2,3 types]{The @Maybe2@ and @Maybe3@ types}
+%*                                                                     *
+%************************************************************************
+
+\begin{code}
+data Maybe2 a b   = Just2 a b   | Nothing2  deriving (Eq,Show)
+data Maybe3 a b c = Just3 a b c | Nothing3  deriving (Eq,Show)
 \end{code}
 
 
@@ -61,17 +66,13 @@ a list of @Justs@ into a single @Just@, returning @Nothing@ if there
 are any @Nothings@.
 
 \begin{code}
-catMaybes :: [Maybe a] -> [a]
-catMaybes []               = []
-catMaybes (Nothing : xs)   = catMaybes xs
-catMaybes (Just x : xs)           = (x : catMaybes xs)
-
 allMaybes :: [Maybe a] -> Maybe [a]
 allMaybes [] = Just []
 allMaybes (Nothing : ms) = Nothing
 allMaybes (Just x  : ms) = case (allMaybes ms) of
                             Nothing -> Nothing
                             Just xs -> Just (x:xs)
+
 \end{code}
 
 @firstJust@ takes a list of @Maybes@ and returns the
@@ -111,6 +112,10 @@ returnMaybe = Just
 
 failMaybe :: Maybe a
 failMaybe = Nothing
+
+orElse :: Maybe a -> a -> a
+(Just x) `orElse` y = x
+Nothing  `orElse` y = y
 \end{code}
 
 Lookup functions
@@ -127,18 +132,6 @@ assocMaybe alist key
   where
     lookup []            = Nothing
     lookup ((tv,ty):rest) = if key == tv then Just ty else lookup rest
-
-#if defined(COMPILING_GHC)
-{-? SPECIALIZE assocMaybe
-       :: [(String,        b)] -> String        -> Maybe b,
-          [(Id,            b)] -> Id            -> Maybe b,
-          [(Class,         b)] -> Class         -> Maybe b,
-          [(Int,           b)] -> Int           -> Maybe b,
-          [(Name,          b)] -> Name          -> Maybe b,
-          [(TyVar,         b)] -> TyVar         -> Maybe b,
-          [(TyVarTemplate, b)] -> TyVarTemplate -> Maybe b
-  #-}
-#endif
 \end{code}
 
 @mkLookupFun eq alist@ is a function which looks up
@@ -193,37 +186,3 @@ failMaB :: err -> MaybeErr val err
 failMaB e = Failed e
 \end{code}
 
-
-@listMaybeErrs@ takes a list of @MaybeErrs@ and, if they all succeed, returns
-a @Succeeded@ of a list of their values.  If any fail, it returns a
-@Failed@ of the list of all the errors in the list.
-
-\begin{code}
-listMaybeErrs :: [MaybeErr val err] -> MaybeErr [val] [err]
-listMaybeErrs
-  = foldr combine (Succeeded [])
-  where
-    combine (Succeeded v) (Succeeded vs) = Succeeded (v:vs)
-    combine (Failed err)  (Succeeded _)         = Failed [err]
-    combine (Succeeded v) (Failed errs)         = Failed errs
-    combine (Failed err)  (Failed errs)         = Failed (err:errs)
-\end{code}
-
-@foldlMaybeErrs@ works along a list, carrying an accumulator; it
-applies the given function to the accumulator and the next list item,
-accumulating any errors that occur.
-
-\begin{code}
-foldlMaybeErrs :: (acc -> input -> MaybeErr acc err)
-              -> acc
-              -> [input]
-              -> MaybeErr acc [err]
-
-foldlMaybeErrs k accum ins = do_it [] accum ins
-  where
-    do_it []   acc []    = Succeeded acc
-    do_it errs acc []    = Failed errs
-    do_it errs acc (v:vs) = case (k acc v) of
-                             Succeeded acc' -> do_it errs       acc' vs
-                             Failed err     -> do_it (err:errs) acc  vs
-\end{code}