[project @ 2000-10-24 08:40:09 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 3cf3221..3f94d34 100644 (file)
--- a/ghc/compiler/utils/Maybes.lhs
+++ b/ghc/compiler/utils/Maybes.lhs
@@ -1,37 +1,44 @@
 %
-% (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
+       Maybe2(..), Maybe3(..),
        MaybeErr(..),
 
+       orElse, 
        mapMaybe,
        allMaybes,
        firstJust,
        expectJust,
        maybeToBool,
 
-       assocMaybe,
-       mkLookupFun, mkLookupFunDef,
+       thenMaybe, seqMaybe, returnMaybe, failMaybe, catMaybes,
+
+       thenMaB, returnMaB, failMaB
 
-       failMaB,
-       failMaybe,
-       seqMaybe,
-       returnMaB,
-       returnMaybe,
-       thenMaB,
-       catMaybes
     ) where
 
-#if __GLASGOW_HASKELL__ >= 204
+#include "HsVersions.h"
+
 import Maybe( catMaybes, mapMaybe )
-#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}
 
 
@@ -60,19 +67,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
@@ -107,56 +101,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
+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}
 
 %************************************************************************
 %*                                                                     *
@@ -181,3 +141,4 @@ returnMaB v = Succeeded v
 failMaB :: err -> MaybeErr val err
 failMaB e = Failed e
 \end{code}
+