Add traceIf function for conditional tracing.

[matthijs/master-project/cλash.git] / cλash / CLasH / Utils.hs

diff --git a/cλash/CLasH/Utils.hs b/cλash/CLasH/Utils.hs
index 94da85494f2216f75b395b542ed6c07b5362ecbf..d85b25b5f415a817a82f54fa5471e1ef5b1aa409 100644 (file)
--- a/cλash/CLasH/Utils.hs
+++ b/cλash/CLasH/Utils.hs
@@ -3,13 +3,11 @@ module CLasH.Utils where
 -- 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
+import qualified Debug.Trace as Trace
   
 -- Make a caching version of a stateful computatation.
 makeCached :: (Monad m, Ord k) =>
@@ -19,14 +17,14 @@ 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) =>
@@ -51,9 +49,21 @@ andM, orM :: (Monad m) => m [Bool] -> m Bool
 andM = Monad.liftM and
 orM = Monad.liftM or
 
+-- | Monadic versions of any and all. We reimplement them, since there
+-- is no ready-made lifting function for them.
+allM, anyM :: (Monad m) => (a -> m Bool) -> [a] -> m Bool
+allM f = andM . (mapM f)
+anyM f = orM . (mapM f)
+
 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)
+
+-- Trace the given string if the given bool is True, do nothing
+-- otherwise.
+traceIf :: Bool -> String -> a -> a
+traceIf True = Trace.trace
+traceIf False = flip const