Is there a way to write an interpreter for log-effectful?

[ParetoOptimalDev]

I feel like there is an easy way to do this that I'm somehow missing. I guessed at this solution:

runLogPure :: Log :> es => Eff (Log : es) a -> Eff es a
runLogPure = do
  Log logger <- getStaticRep
  unsafeEff_ $ logMessage logger msg

After reading Effectful.Dispatch.Static and seeing how runLog is defined.

Or maybe no one else has a use for a pure interpreter?

Do others not test their effectful programs that use logs or does everyone roll their own logging effect?

[ParetoOptimalDev]

Looking through issues I see a Console effect was recommended like Polysemy's trace here.

It looks like this Console effect is added in a recent PR as well.

However I was hoping for the ability to purely use log-base so I could have different log levels.

I would like to use one of the log levels for tests along with a writer monad.

[ocharles]

I haven't worked out where to put this comment, but I think the Haskell community is a bit too focused on creating pure variants of interpreters. This is one way to do it, but I find the approach outlined in https://www.jamesshore.com/v2/projects/nullables/testing-without-mocks to be a better one. Though this is a bit OO-centric, the general idea when applied to effects is that we don't want to replace entire effects, but rather we want to run an effect with a pure backing. When we take this stance, log-effectful does become amenable to pure logging - simply supply a pure Logger:

newNullLogger :: IO Logger
newNullLogger = mkLogger mempty mempty

foo = do
  logger <- newNullLogger
  runEff $ runLog mempty logger minBound $ app

[ParetoOptimalDev]

If I understand correctly, from this perspective "make my test totally pure" becomes a non-goal?

What if you want to use property tests on your programs? What if you want tests to be pure to totally rule out test pollution that can be caused by anything IO?

Thanks for the answer though, I see a way forward at least even with those outstanding questions.

I'm reading the linked article in full now.

[ocharles]

Yea, I don't find that a particularly interesting goal. All property testing frameworks I know of are fine with IO. I mostly use Hedgehog, so I just need to add a single evalIO call.

[ParetoOptimalDev]

Okay, I think I'm understanding your point of view.

Would it also be accurate to say that you don't find pure interpreters very useful in general then?

If that's the case, it seems if one believes that then effect systems don't have much of advantage with regards to testing over something like mtl and say monad-mock or hmock.

[ocharles]

No I think that's a bit too an extreme position. But it does depend on the effect. For something like logging I'm not generally dispatching it in the middle of a program - so here needing a bit of IO or something is fine. However for something like state I do want that in the middle, so here purity might be more useful. Effectful still wins for me though by giving us a concrete monad to work in, which means we don't pay an abstraction cost for every bind

[arybczak]

If you want to collect logs instead of displaying them, there are appropriate loggers for this purpose - see Log.Backend.LogList and Log.Backend.Text.