\begin{code}
module Maybes (
- Maybe2(..), Maybe3(..),
- MaybeErr(..),
+ module Maybe, -- Re-export all of Maybe
+
+ MaybeErr(..), -- Instance of Monad
+ failME,
orElse,
- mapMaybe,
+ mapCatMaybes,
allMaybes,
firstJust,
expectJust,
maybeToBool,
- assocMaybe,
- mkLookupFun, mkLookupFunDef,
-
- failMaB,
- failMaybe,
- seqMaybe,
- returnMaB,
- returnMaybe,
- thenMaB,
- catMaybes
+ thenMaybe, seqMaybe, returnMaybe, failMaybe
) where
#include "HsVersions.h"
-import Maybe( catMaybes, mapMaybe )
+import Maybe
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}
-
-
%************************************************************************
%* *
\subsection[Maybe type]{The @Maybe@ type}
\end{code}
\begin{code}
-findJust :: (a -> Maybe b) -> [a] -> Maybe b
-findJust f [] = Nothing
-findJust f (a:as) = case f a of
- Nothing -> findJust f as
- b -> b
-\end{code}
-
-\begin{code}
expectJust :: String -> Maybe a -> a
{-# INLINE expectJust #-}
expectJust err (Just x) = x
expectJust err Nothing = error ("expectJust " ++ err)
\end{code}
+\begin{code}
+mapCatMaybes :: (a -> Maybe b) -> [a] -> [b]
+mapCatMaybes f [] = []
+mapCatMaybes f (x:xs) = case f x of
+ Just y -> y : mapCatMaybes f xs
+ Nothing -> mapCatMaybes f xs
+\end{code}
+
The Maybe monad
~~~~~~~~~~~~~~~
\begin{code}
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
Nothing `orElse` y = y
\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
-\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}
%************************************************************************
%* *
%************************************************************************
\begin{code}
-data MaybeErr val err = Succeeded val | Failed err
-\end{code}
-
-\begin{code}
-thenMaB :: MaybeErr val1 err -> (val1 -> MaybeErr val2 err) -> MaybeErr val2 err
-thenMaB m k
- = case m of
- Succeeded v -> k v
- Failed e -> Failed e
+data MaybeErr err val = Succeeded val | Failed err
-returnMaB :: val -> MaybeErr val err
-returnMaB v = Succeeded v
+instance Monad (MaybeErr err) where
+ return v = Succeeded v
+ Succeeded v >>= k = k v
+ Failed e >>= k = Failed e
-failMaB :: err -> MaybeErr val err
-failMaB e = Failed e
+failME :: err -> MaybeErr err val
+failME e = Failed e
\end{code}
-