Pre/post processing in Effect handler

[emlautarom1]

Assume that I have the following Effect:

data Severity = Info | Error | Fatal
  deriving (Show, Eq, Ord, Bounded)

data Logger e :: Effect where
  Log :: Severity -> String -> (Logger e) m ()

type instance DispatchOf (Logger e) = Dynamic

log :: (Logger e :> es) => Severity -> String -> Eff es ()
log severity message = send $ Log severity message

I would like to write an interpreter that:

1. Takes a FilePath as argument
2. Opens the file in WriteMode once
3. Every 10 writes it flushes the file handle

(this is just an example use case, not something real)

As a skeleton I have something like:

runFileLogger :: (IOE :> es) => FilePath -> Eff (Logger e : es) a -> Eff es a
runFileLogger path = do
  -- Use `withFile` or similar to get a `Handle`. The file should be opened once.
  -- withFile path WriteMode $ \handle ->
  -- Store some kind of counter variable (`IORef` maybe?)
  -- counter <- ???
  interpret $ \env op -> case op of
    Log severity message -> do
      -- update the counter
      liftIO $ hPutStrLn handle message
      -- if the counter reaches 10, call `hFlush handle`

1. The signature runFileLogger :: (IOE :> es) => FilePath -> Eff (Logger e : es) a -> Eff es a is what I would like to have.
2. Notice how certain operations should be executed "before" the interpret call
3. We're dealing with the withXXX pattern since we want to do something before & after interpreting the Effect: open the file and closing it.

[emlautarom1]

After some trial and error I ended up with:

runFileLogger :: (IOE :> es) => FilePath -> Eff (Logger e : es) a -> Eff es a
runFileLogger path logger = do
  counter <- liftIO $ newIORef (0 :: Int)
  withFile path WriteMode $ \handle -> do
    interpretWith logger $ \_ -> \case
      Log severity message -> liftIO $ do
        atomicModifyIORef' counter $ \c -> (c + 1, ())
        hPutStrLn handle message
        whenM ((== 10) <$> readIORef counter) $ do
          hFlush handle
          atomicModifyIORef' counter $ const (0, ())

This is pretty much what I was looking for but there are a couple of issues:

1. This requires unliftio as a dependency to workaround the IO limitation of System.IO.withFile.
2. There are several usages of liftIO scattered throughout the implementation.

These are very small issues but I would like to know if there is any way to remove them.

[arybczak]

These are very small issues

Why do you think they are issues? This looks fine to me 🤔

[arybczak]

This requires unliftio as a dependency to workaround the IO limitation of System.IO.withFile.

You can use withSeqEffToIO and unlift withFile from base manually.

[emlautarom1]

These are very small issues

Why do you think they are issues? This looks fine to me 🤔

It would be nice if I didn't have to add another explicit dependency, but I guess it's fine given the ubiquity of unliftio.

This requires unliftio as a dependency to workaround the IO limitation of System.IO.withFile.

You can use withSeqEffToIO and unlift withFile from base manually.

How would that look like? I'd rather import UnliftIO.IO than writing more code but it would be nice to know how either way.

[arybczak]

runFileLogger :: (IOE :> es) => FilePath -> Eff (Logger e : es) a -> Eff es a
runFileLogger path logger = do
  counter <- liftIO $ newIORef (0 :: Int)
  withSeqEffToIO $ \unlift -> withFile path WriteMode $ \handle -> unlift $ do
    interpretWith logger $ \_ -> \case
      Log severity message -> liftIO $ do
        atomicModifyIORef' counter $ \c -> (c + 1, ())
        hPutStrLn handle message
        whenM ((== 10) <$> readIORef counter) $ do
          hFlush handle
          atomicModifyIORef' counter $ const (0, ())