Re: [Haskell-cafe] Caching Actions

25 Jan 2018

      On Thu, 2018-01-25 at 09:50 +0000, Yotam Ohad wrote:
...
Hi,
I've been digging around the source code of reactive-banana and I
found this code: 
data Cached m a = Cached (m a)
runCached :: Cached m a -> m a
runCached (Cached x) = x
-- | An action whose result will be cached.
-- Executing the action the first time in the monad will
-- execute the side effects. From then on,
-- only the generated value will be returned.
{-# NOINLINE cache #-}
cache :: (MonadFix m, MonadIO m) => m a -> Cached m a
cache m = unsafePerformIO $ do
    key <- liftIO $ newIORef Nothing
    return $ Cached $ do
        ma <- liftIO $ readIORef key    -- read the cached result
        case ma of
            Just a  -> return a         -- return the cached result.
            Nothing -> mdo
                liftIO $                -- write the result already
                    writeIORef key (Just a)
                a <- m                  -- evaluate
                return a
I'm trying to understand the reasom behind the use of mdo. Can't it
be like this:
do
  a <- m
  liftIO $ writeIORef key (Just a)
  return a
Removing the need for a recursive definition?
Yotam
_______________________________________________
I ran into a need for something similar for FRP myself. I agree that
one probably has to be careful about duplicate/concurrent evaluation.
My solution at the time was an action, which returns an action that is
performed only once:

lazyIO :: IO a -> IO (IO a)
lazyIO action = do
    box <- newMVar Nothing
    return $ modifyMVar box storeResultOnce
    where
    storeResultOnce m@(Just result) = return (m, result)
    storeResultOnce _ = action >>= \r -> return (Just r, r)
{-# RULES "optimize lazyIO" lazyIO = unsafeInterleaveIO . (pure <$>) 
#-}

I think you need to change the type of the cache function if you want
to avoid unsafe IO functions at all:
cache :: (MonadFix m, MonadIO m) => m a -> m (Cached m a)

unsafePerformIO [1] already prevents duplicate/concurrent evaluation of
its argument. And if you're using unsafe IO already, why not simplify
it to just using unsafeInterleaveIO? It has the same guarantees about
no duplication according to its Haskell source.

[1] https://hackage.haskell.org/package/base-4.10.1.0/docs/System-IO-Un
safe.html

Re: [Haskell-cafe] Caching Actions

Arjen