import FastString
import SrcLoc
import Util
+import Maybes
import Control.Exception
import Control.Monad
import qualified Data.Map as Map
import Data.Array.Unboxed
-import Data.Traversable ( traverse )
import Data.Typeable ( Typeable )
import Data.Maybe
import Data.IORef
-- Give names to suspensions and bind them in the local env
mb_terms' <- if bindThings
- then io$ mapM (traverse (bindSuspensions cms)) mb_terms
+ then io$ mapM (fmapMMaybe (bindSuspensions cms)) mb_terms
else return mb_terms
- ppr_terms <- io$ mapM (traverse (printTerm cms)) mb_terms'
+ ppr_terms <- io$ mapM (fmapMMaybe (printTerm cms)) mb_terms'
let docs = [ ppr id <+> char '=' <+> t | (Just t,id) <- zip ppr_terms ids]
unqual <- io$ GHC.getPrintUnqual cms
io . putStrLn . showSDocForUser unqual $ Outputable.vcat docs
import Constants ( wORD_SIZE )\r
import FastString ( mkFastString )\r
import Outputable\r
+import Maybes\r
import Panic\r
\r
import GHC.Arr ( Array(..) )\r
import Control.Monad ( liftM, liftM2, msum )\r
import Data.Maybe\r
import Data.List\r
-import Data.Traversable ( mapM )\r
import Data.Array.Base\r
import Foreign.Storable\r
import Foreign ( unsafePerformIO )\r
\r
-import Prelude hiding ( mapM )\r
-\r
---------------------------------------------\r
-- * A representation of semi evaluated Terms\r
---------------------------------------------\r
fTerm = \ty dc v tt -> sequence tt >>= \tt ->\r
zonkTcType ty >>= \ty' ->\r
return (Term ty' dc v tt)\r
- ,fSuspension = \ct ty v b -> mapM zonkTcType ty >>= \ty ->\r
+ ,fSuspension = \ct ty v b -> fmapMMaybe zonkTcType ty >>= \ty ->\r
return (Suspension ct ty v b)} \r
\r
{-\r
import System.Time ( ClockTime )
import Control.Exception as Exception hiding (handle)
import Data.IORef
-import Data.Traversable ( traverse )
import System.IO
import System.IO.Error ( isDoesNotExistError )
import Prelude hiding (init)
expectJust,
maybeToBool,
- thenMaybe, seqMaybe, returnMaybe, failMaybe
+ thenMaybe, seqMaybe, returnMaybe, failMaybe, fmapMMaybe
) where
#include "HsVersions.h"
orElse :: Maybe a -> a -> a
(Just x) `orElse` y = x
Nothing `orElse` y = y
+
+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')
+
\end{code}