-- Standard Imports
import qualified Maybe
import Data.Accessor
+import qualified Data.Accessor.Monad.Trans.State as MonadState
import qualified Data.Map as Map
import qualified Control.Monad as Monad
import qualified Control.Monad.Trans.State as State
-
--- GHC API
-
--- Local Imports
-- Make a caching version of a stateful computatation.
makeCached :: (Monad m, Ord k) =>
-> State.StateT s m v -- ^ The resulting value, from the cache or freshly
-- computed.
makeCached key accessor create = do
- cache <- getA accessor
+ cache <- MonadState.get accessor
case Map.lookup key cache of
-- Found in cache, just return
Just value -> return value
-- Not found, compute it and put it in the cache
Nothing -> do
value <- create
- modA accessor (Map.insert key value)
+ MonadState.modify accessor (Map.insert key value)
return value
unzipM :: (Monad m) =>
isJustM :: (Monad m) => m (Maybe a) -> m Bool
isJustM = Monad.liftM Maybe.isJust
+
+andM, orM :: (Monad m) => m [Bool] -> m Bool
+andM = Monad.liftM and
+orM = Monad.liftM or
+
+mapAccumLM :: (Monad m) => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])
+mapAccumLM _ s [] = return (s, [])
+mapAccumLM f s (x:xs) = do
+ (s', y ) <- f s x
+ (s'', ys) <- mapAccumLM f s' xs
+ return (s'', y:ys)