Some refactoring and simplification in TcInteract.occurCheck
[ghc.git] / compiler / utils / Maybes.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 \begin{code}
7 module Maybes (
8         module Data.Maybe,
9
10         MaybeErr(..), -- Instance of Monad
11         failME, isSuccess,
12
13         fmapM_maybe,
14         orElse,
15         mapCatMaybes,
16         allMaybes,
17         firstJust, firstJusts,
18         expectJust,
19         maybeToBool,
20
21         MaybeT(..)
22     ) where
23
24 import Data.Maybe
25
26 infixr 4 `orElse`
27 \end{code}
28
29 %************************************************************************
30 %*                                                                      *
31 \subsection[Maybe type]{The @Maybe@ type}
32 %*                                                                      *
33 %************************************************************************
34
35 \begin{code}
36 maybeToBool :: Maybe a -> Bool
37 maybeToBool Nothing  = False
38 maybeToBool (Just _) = True
39
40 -- | Collects a list of @Justs@ into a single @Just@, returning @Nothing@ if
41 -- there are any @Nothings@.
42 allMaybes :: [Maybe a] -> Maybe [a]
43 allMaybes [] = Just []
44 allMaybes (Nothing : _)  = Nothing
45 allMaybes (Just x  : ms) = case allMaybes ms of
46                            Nothing -> Nothing
47                            Just xs -> Just (x:xs)
48
49 firstJust :: Maybe a -> Maybe a -> Maybe a
50 firstJust (Just a) _ = Just a
51 firstJust Nothing  b = b
52
53 -- | Takes a list of @Maybes@ and returns the first @Just@ if there is one, or
54 -- @Nothing@ otherwise.
55 firstJusts :: [Maybe a] -> Maybe a
56 firstJusts = foldr firstJust Nothing
57 \end{code}
58
59 \begin{code}
60 expectJust :: String -> Maybe a -> a
61 {-# INLINE expectJust #-}
62 expectJust _   (Just x) = x
63 expectJust err Nothing  = error ("expectJust " ++ err)
64 \end{code}
65
66 \begin{code}
67 mapCatMaybes :: (a -> Maybe b) -> [a] -> [b]
68 mapCatMaybes _ [] = []
69 mapCatMaybes f (x:xs) = case f x of
70                         Just y  -> y : mapCatMaybes f xs
71                         Nothing -> mapCatMaybes f xs
72 \end{code}
73
74 \begin{code}
75
76 orElse :: Maybe a -> a -> a
77 (Just x) `orElse` _ = x
78 Nothing  `orElse` y = y
79 \end{code}
80
81 \begin{code}
82 fmapM_maybe :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)
83 fmapM_maybe _ Nothing = return Nothing
84 fmapM_maybe f (Just x) = do
85         x' <- f x
86         return $ Just x'
87 \end{code}
88
89 %************************************************************************
90 %*                                                                      *
91 \subsection[MaybeT type]{The @MaybeT@ monad transformer}
92 %*                                                                      *
93 %************************************************************************
94
95 \begin{code}
96
97 newtype MaybeT m a = MaybeT {runMaybeT :: m (Maybe a)}
98
99 instance Functor m => Functor (MaybeT m) where
100   fmap f x = MaybeT $ fmap (fmap f) $ runMaybeT x
101
102 instance Monad m => Monad (MaybeT m) where
103   return = MaybeT . return . Just
104   x >>= f = MaybeT $ runMaybeT x >>= maybe (return Nothing) (runMaybeT . f)
105   fail _ = MaybeT $ return Nothing
106
107 \end{code}
108
109
110 %************************************************************************
111 %*                                                                      *
112 \subsection[MaybeErr type]{The @MaybeErr@ type}
113 %*                                                                      *
114 %************************************************************************
115
116 \begin{code}
117 data MaybeErr err val = Succeeded val | Failed err
118
119 instance Monad (MaybeErr err) where
120   return v = Succeeded v
121   Succeeded v >>= k = k v
122   Failed e    >>= _ = Failed e
123
124 isSuccess :: MaybeErr err val -> Bool
125 isSuccess (Succeeded {}) = True
126 isSuccess (Failed {})    = False
127
128 failME :: err -> MaybeErr err val
129 failME e = Failed e
130 \end{code}