Would you consider this a good solution instead?

instance (MonadLog m) => MonadFoo0 (FooT m) where
  foo0 :: FooT m Foo
  foo0 = do
    logMsg (Msg "fetching foo")
    pure Foo

newtype CorrelatedConsoleLogT m a = CorrelatedConsoleLogT
  { unCorrelatedConsoleLogT :: CorrelatedT m a }
  deriving newtype (Functor, Applicative, Monad)
  deriving (MonadTrans, MonadTransControl) via CorrelatedT

runCorrelatedConsoleLogT :: forall m a. (MonadLog m) => CorrelationId -> CorrelatedConsoleLogT m a -> m a
runCorrelatedConsoleLogT correlationId = runCorrelatedT correlationId . unCorrelatedConsoleLogT

instance MonadLog m => MonadLog (CorrelatedConsoleLogT m) where
  logMsg (Msg msg) = CorrelatedConsoleLogT . CorrelatedT $ do
    CorrelationId correlationId <- ask @CorrelationId
    logMsg (Msg (correlationId <> ": " <> msg))

main0 :: IO ()
main0
  = runConsoleLogT abstractMain0

abstractMain0 ::
     MonadLog m
  => m ()
abstractMain0 = handleRequests requestHandler0

requestHandler0 ::
  (MonadLog m)
  => CorrelationId
  -> m Foo
requestHandler0 correlationId =
  runCorrelatedConsoleLogT correlationId .
  runFooT Foo $ foo0

In the code above requestHandler0 discharge the Correlated constraint by using a CorrelatedConsoleLogT which leaves only the MonadLog constraint which can then be fulfilled by a regular runConsoleT.

The main difference is that the MonadLog instance for "correlated logging" is implemented with another MonadLog instance which does not require correlation.

Hi @symbiont-eric-torreborre, thanks for your solution. I didn't state it in the gist, but another goal of mine is to keep runFooT in main, since many different handlers will make use of the MonadFoo effect and I want them to share the same implementation. In other words, abstractMain should have a MonadFoo m constraint. Another problem with your solution is that the user (requestHandler) needs to remember to use runCorrelatedConsoleLogT, and I don't trust myself to remember that :) so I want the type of foo to remind me in some way (in my solution, foo has a Correlated m constraint).

Thanks for giving me all the constraints. We actually have a fairly similar problem at work :-). But we are using records-of-functions instead of monad transformers. I give you a solution which uses registry, a library for constructing records of functions but you could do all the wiring manually:

import Control.Monad.Reader (ReaderT (..), ask)
import Control.Monad.Trans.Class (MonadTrans (..))
import Control.Monad.IO.Class (MonadIO (..))
import Prelude hiding (log)
import Data.Registry

--------------------------------------------------------------------------------
-- # Logging

newtype CorrelationId = CorrelationId String
newtype Msg = Msg { unMsg :: String }

newtype Logger m = Logger { logMsg :: Msg -> m () }

newLogger :: MonadIO m => Logger m
newLogger = Logger (liftIO . putStrLn . unMsg)

-- | This logger requires a context with a CorrelationId
-- | This logger requires a context with a CorrelationId
newCorrelatedLogger :: Monad m => Logger m -> Logger (ReaderT CorrelationId m)
newCorrelatedLogger logger = Logger {..} where

  logMsg :: Msg -> m ()
  logMsg (Msg msg) = do
    CorrelationId correlationId <- ask
    lift $ logMsg logger (Msg $ correlationId <> ":" <> msg)

--------------------------------------------------------------------------------
-- # Fooing

data Foo = Foo deriving (Eq, Show)
newtype FooService m = FooService { doFoo :: m Foo }

newFooService :: Monad m => Foo -> Logger m -> FooService m
newFooService foo logger = FooService $ do
  logMsg logger (Msg "produce a Foo")
  pure foo

--------------------------------------------------------------------------------
-- # Handling requests

newtype RequestHandler m = RequestHandler { requestHandler :: CorrelationId -> m Foo }

-- | The FooService is constrained to use correlation ids
newRequestHandler :: FooService (ReaderT CorrelationId m) -> RequestHandler m
newRequestHandler fooService = RequestHandler $ \correlationId ->
  flip runReaderT correlationId $ doFoo fooService

-- | Define a registry containing all the components constructors
registry =
    -- this value is used to setup the FooService
     val Foo
  -- the Handler needs a FooService (ReaderT CorrelationId IO)
  -- (other handlers would use the same implementation)
  <: fun (newRequestHandler @IO)
  -- this requires to have a Logger (ReaderT CorrelationId IO) in the registry
  <: fun (newFooService @(ReaderT CorrelationId IO))
  -- this is a Logger (ReaderT CorrelationId IO), it needs a Logger IO
  <: fun (newCorrelatedLogger @IO)
  -- this is a Logger IO
  <: fun (newLogger @IO)


--------------------------------------------------------------------------------
-- # Main

main :: IO ()
main = do
  -- we make all the top-level handlers here
  let RequestHandler requestHandler = make @(RequestHandler IO) registry
  -- and start handling requests
  handleRequests requestHandler

-- | Pretend this is a handler for HTTP requests, SQS messages, whatever.
handleRequests :: (a -> m b) -> m ()
handleRequests = undefined

I think that satisfies your constraints:

• the FooService implementation is shared by all the handlers
• it uses a Logger and does not need to know about CorrelationIds
• when used inside a handler the FooService has to be passed a CorrelationId in order to be called
• logging with a CorrelationId uses the general code for logging messages

All in all I find using records of functions more practical when there are lots of components provided there's a good wiring solution (registry is one of them, there can be other approaches)