X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Futils%2FMaybes.lhs;h=39e6185a19eedbc355a31573e951e5ac0f05994b;hp=af7d3f6ca51c3e3fecfc88dcf6a26426702d969e;hb=8133a9f47b99f4e65ed30551de32ad72c6b61b27;hpb=fbb68f1d6abfa3391e2cd0ea8f3c1a62ef911634

diff --git a/compiler/utils/Maybes.lhs b/compiler/utils/Maybes.lhs
index af7d3f6..39e6185 100644
--- a/compiler/utils/Maybes.lhs
+++ b/compiler/utils/Maybes.lhs
@@ -5,113 +5,112 @@
 
 \begin{code}
 module Maybes (
-	module Data.Maybe,	-- Re-export all of Maybe
+        module Data.Maybe,
 
-	MaybeErr(..),	-- Instance of Monad
-	failME, isSuccess,
+        MaybeErr(..), -- Instance of Monad
+        failME, isSuccess,
 
-	orElse, 
-	mapCatMaybes,
-	allMaybes,
-	firstJust,
-	expectJust,
-	maybeToBool,
+        fmapM_maybe,
+        orElse,
+        mapCatMaybes,
+        allMaybes,
+        firstJust, firstJusts,
+        expectJust,
+        maybeToBool,
 
-	thenMaybe, seqMaybe, returnMaybe, failMaybe, fmapMMaybe
+        MaybeT(..)
     ) where
 
-#include "HsVersions.h"
-
 import Data.Maybe
 
 infixr 4 `orElse`
 \end{code}
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[Maybe type]{The @Maybe@ type}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 maybeToBool :: Maybe a -> Bool
 maybeToBool Nothing  = False
-maybeToBool (Just x) = True
-\end{code}
+maybeToBool (Just _) = True
 
-@catMaybes@ takes a list of @Maybe@s and returns a list of
-the contents of all the @Just@s in it.	@allMaybes@ collects
-a list of @Justs@ into a single @Just@, returning @Nothing@ if there
-are any @Nothings@.
-
-\begin{code}
+-- | Collects a list of @Justs@ into a single @Just@, returning @Nothing@ if
+-- there are any @Nothings@.
 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
-first @Just@ if there is one, or @Nothing@ otherwise.
-
-\begin{code}
-firstJust :: [Maybe a] -> Maybe a
-firstJust [] = Nothing
-firstJust (Just x  : ms) = Just x
-firstJust (Nothing : ms) = firstJust ms
+allMaybes (Nothing : _)  = Nothing
+allMaybes (Just x  : ms) = case allMaybes ms of
+                           Nothing -> Nothing
+                           Just xs -> Just (x:xs)
+
+firstJust :: Maybe a -> Maybe a -> Maybe a
+firstJust (Just a) _ = Just a
+firstJust Nothing  b = b
+
+-- | Takes a list of @Maybes@ and returns the first @Just@ if there is one, or
+-- @Nothing@ otherwise.
+firstJusts :: [Maybe a] -> Maybe a
+firstJusts = foldr firstJust Nothing
 \end{code}
 
 \begin{code}
 expectJust :: String -> Maybe a -> a
 {-# INLINE expectJust #-}
-expectJust err (Just x) = x
+expectJust _   (Just x) = x
 expectJust err Nothing  = error ("expectJust " ++ err)
 \end{code}
 
 \begin{code}
 mapCatMaybes :: (a -> Maybe b) -> [a] -> [b]
-mapCatMaybes f [] = []
+mapCatMaybes _ [] = []
 mapCatMaybes f (x:xs) = case f x of
-			  Just y  -> y : mapCatMaybes f xs
-			  Nothing -> mapCatMaybes f xs
+                        Just y  -> y : mapCatMaybes f xs
+                        Nothing -> mapCatMaybes f xs
 \end{code}
 
-The Maybe monad
-~~~~~~~~~~~~~~~
 \begin{code}
-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
+orElse :: Maybe a -> a -> a
+(Just x) `orElse` _ = x
+Nothing  `orElse` y = y
+\end{code}
 
-returnMaybe :: a -> Maybe a
-returnMaybe = Just
+\begin{code}
+fmapM_maybe :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)
+fmapM_maybe _ Nothing = return Nothing
+fmapM_maybe f (Just x) = do
+        x' <- f x
+        return $ Just x'
+\end{code}
 
-failMaybe :: Maybe a
-failMaybe = Nothing
+%************************************************************************
+%*									*
+\subsection[MaybeT type]{The @MaybeT@ monad transformer}
+%*									*
+%************************************************************************
 
-orElse :: Maybe a -> a -> a
-(Just x) `orElse` y = x
-Nothing  `orElse` y = y
+\begin{code}
+
+newtype MaybeT m a = MaybeT {runMaybeT :: m (Maybe a)}
 
-fmapMMaybe :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)
-fmapMMaybe f Nothing  = return Nothing
-fmapMMaybe f (Just x) = f x >>= \x' -> return (Just x')
+instance Functor m => Functor (MaybeT m) where
+  fmap f x = MaybeT $ fmap (fmap f) $ runMaybeT x
+
+instance Monad m => Monad (MaybeT m) where
+  return = MaybeT . return . Just
+  x >>= f = MaybeT $ runMaybeT x >>= maybe (return Nothing) (runMaybeT . f)
+  fail _ = MaybeT $ return Nothing
 
 \end{code}
 
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[MaybeErr type]{The @MaybeErr@ type}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -120,7 +119,7 @@ data MaybeErr err val = Succeeded val | Failed err
 instance Monad (MaybeErr err) where
   return v = Succeeded v
   Succeeded v >>= k = k v
-  Failed e    >>= k = Failed e
+  Failed e    >>= _ = Failed e
 
 isSuccess :: MaybeErr err val -> Bool
 isSuccess (Succeeded {}) = True