Question

The problem is this. I have:

f :: MonadIO m => ReaderT FooBar m Answer;
f = (liftIO getArgs) >>= ...

I need to run this with modified arguments. However, since m is unknown, I cannot simply use

mapReaderT (withArgs args) :: ReaderT r IO b -> ReaderT r IO b

since I need somehow to transform (withArgs args) into m for all m.

One possibility I found is to define my own withArgs, thus:

import System.Environment (setArgs, freeArgv);
withArgv new_args act = do {
  pName <- liftIO System.Environment.getProgName;
  existing_args <- liftIO System.Environment.getArgs;
  bracket (liftIO $ setArgs new_args)
          (\argv -> do {
                      _ <- liftIO $ setArgs (pName:existing_args);
                      liftIO $ freeArgv argv;
                    })
          (const act);
};

withArgs xs act = do {
  p <- liftIO System.Environment.getProgName;
  withArgv (p:xs) act;
};

However, this is a kludge, and specific to one function — I would need to re-write every withX :: X -> IO a -> IO a, e.g. Control.Exception.handle

What, if any, is a better way to do this?

Edit: In the case of handle, I found Control.Monad.CatchIO. In the other case, I used yet another, briefer kludge (not worth posting) to avoid the kludge above. Still seeking a better solution!

Answer 1

The monad-control package will do this. I think you want the function liftIOOp_ from Control.Monad.IO.Control.

Specifically,

liftIOOp_ (withArgs newArgs) f

should do what you want. You can lift things like bracket too, with the liftIOOp function.