Simple storage that you can use to control concurrent evaluations.

storage.hs

import Control.Concurrent.Async
import Control.Concurrent.STM
import Control.Exception
import Control.Monad
import qualified Data.Map as Map
import Data.Map (Map)
import System.IO.Unsafe

-- | Version1 - starts async only when it's evaluated
-- Composable
--
createOrLoad :: Ord k => TVar (Map k (Async ())) -> k -> STM (Async ())
createOrLoad t k = do
    c <- readTVar t
    case Map.lookup k c of
      Nothing -> do writeTVar t (Map.insert k a c)
                    return a
      Just x  -> return x
  where
    a = unsafePerformIO $ async $ return ()

-- | Do not use unsafe stuff, async is created immediately
-- Non composable (Uses IO).
-- Readers rerun transaction on each change (stm-containers is a solution).
-- Exception safe
createOrLoad2 :: Ord k => TVar (Map k (Either () (Async ()))) -> k -> IO (Async ())
createOrLoad2 t k = join internal where
  internal = atomically $ do
    c <- readTVar t
    case Map.lookup k c of
      Nothing -> do
        modifyTVar' t (Map.insert k (Left ()))
        return $ mask_ $ do
          a <- async $ return ()
          atomically $ modifyTVar' t (Map.insert k (Right a))
          return a
      Just (Left _) -> retry
      Just (Right x) -> return $ return x