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