ghc/compiler/utils/Maybes.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[Maybes]{The `Maybe' types and associated utility functions}
   5
   6 \begin{code}
   7 module Maybes (
   8         MaybeErr(..),
   9
  10         orElse,
  11         mapMaybe,
  12         allMaybes,
  13         firstJust,
  14         expectJust,
  15         maybeToBool,
  16
  17         thenMaybe, seqMaybe, returnMaybe, failMaybe, catMaybes,
  18
  19         thenMaB, returnMaB, failMaB
  20
  21     ) where
  22
  23 #include "HsVersions.h"
  24
  25 import Maybe( catMaybes, mapMaybe )
  26
  27
  28 infixr 4 `orElse`
  29 \end{code}
  30
  31 %************************************************************************
  32 %*                                                                      *
  33 \subsection[Maybe type]{The @Maybe@ type}
  34 %*                                                                      *
  35 %************************************************************************
  36
  37 \begin{code}
  38 maybeToBool :: Maybe a -> Bool
  39 maybeToBool Nothing  = False
  40 maybeToBool (Just x) = True
  41 \end{code}
  42
  43 @catMaybes@ takes a list of @Maybe@s and returns a list of
  44 the contents of all the @Just@s in it.  @allMaybes@ collects
  45 a list of @Justs@ into a single @Just@, returning @Nothing@ if there
  46 are any @Nothings@.
  47
  48 \begin{code}
  49 allMaybes :: [Maybe a] -> Maybe [a]
  50 allMaybes [] = Just []
  51 allMaybes (Nothing : ms) = Nothing
  52 allMaybes (Just x  : ms) = case (allMaybes ms) of
  53                              Nothing -> Nothing
  54                              Just xs -> Just (x:xs)
  55
  56 \end{code}
  57
  58 @firstJust@ takes a list of @Maybes@ and returns the
  59 first @Just@ if there is one, or @Nothing@ otherwise.
  60
  61 \begin{code}
  62 firstJust :: [Maybe a] -> Maybe a
  63 firstJust [] = Nothing
  64 firstJust (Just x  : ms) = Just x
  65 firstJust (Nothing : ms) = firstJust ms
  66 \end{code}
  67
  68 \begin{code}
  69 findJust :: (a -> Maybe b) -> [a] -> Maybe b
  70 findJust f []     = Nothing
  71 findJust f (a:as) = case f a of
  72                       Nothing -> findJust f as
  73                       b  -> b
  74 \end{code}
  75
  76 \begin{code}
  77 expectJust :: String -> Maybe a -> a
  78 {-# INLINE expectJust #-}
  79 expectJust err (Just x) = x
  80 expectJust err Nothing  = error ("expectJust " ++ err)
  81 \end{code}
  82
  83 The Maybe monad
  84 ~~~~~~~~~~~~~~~
  85 \begin{code}
  86 seqMaybe :: Maybe a -> Maybe a -> Maybe a
  87 seqMaybe (Just x) _  = Just x
  88 seqMaybe Nothing  my = my
  89
  90 thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
  91 thenMaybe ma mb = case ma of
  92                     Just x  -> mb x
  93                     Nothing -> Nothing
  94
  95 returnMaybe :: a -> Maybe a
  96 returnMaybe = Just
  97
  98 failMaybe :: Maybe a
  99 failMaybe = Nothing
 100
 101 orElse :: Maybe a -> a -> a
 102 (Just x) `orElse` y = x
 103 Nothing  `orElse` y = y
 104 \end{code}
 105
 106
 107 %************************************************************************
 108 %*                                                                      *
 109 \subsection[MaybeErr type]{The @MaybeErr@ type}
 110 %*                                                                      *
 111 %************************************************************************
 112
 113 \begin{code}
 114 data MaybeErr val err = Succeeded val | Failed err
 115 \end{code}
 116
 117 \begin{code}
 118 thenMaB :: MaybeErr val1 err -> (val1 -> MaybeErr val2 err) -> MaybeErr val2 err
 119 thenMaB m k
 120   = case m of
 121       Succeeded v -> k v
 122       Failed e    -> Failed e
 123
 124 returnMaB :: val -> MaybeErr val err
 125 returnMaB v = Succeeded v
 126
 127 failMaB :: err -> MaybeErr val err
 128 failMaB e = Failed e
 129 \end{code}
 130