Handling an effect using local env and global handlers

[ocharles]

I have a bit of an interesting situation, and I'm curious if effectful has a solution here.

I have one Effect, defined as:

data Hardware :: Effect where
  WithResizedMoverAt :: EventWriter :> es => MoverId -> Point V2 Int -> Maybe (V2 Length) -> Eff es a -> Hardware (Eff es) a

As you can see, calling withResizedMoverAt requires you to have an EventWriter:

data EventWriter :: Effect where
  AppendEvent :: ToJSON a => a -> EventWriter m ()

EventWriter has an interpreter that takes a JobId, and prefixes all events with that job id.

runEventWriter ::
  forall {es} job a.
  (IOE :> es, DB :> es, Show job) =>
  JobId ->
  job ->
  Eff (EventWriter : es) a ->
  Eff es a

I also have an interpreter for Hardware, but this is where things get tricky:

runHardware :: (IOE :> es, Statement :> es) => HW.Hardware -> Eff (Hardware ': es) a -> Eff es a
runHardware hw m = do
  initialState <- newState
  reinterpret (evalState initialState) interpreter m
  where
    interpreter ::
      (IOE :> es, State HardwareState :> es, Statement :> es) =>
      LocalEnv localEs es ->
      Hardware (Eff localEs) a ->
      Eff es a
    interpreter env = \case
      WithResizedMoverAt moverId targetLocation newSize k ->
        ...
        routerMover ...

Where

routeMover :: (IOE :> es, EventWriter :> es) => HW.Hardware -> RouteMover -> Eff es ()

Notice that routeMover requires IOE and EventWriter, but in the runHardware interpreter, afaik I can only be in es or localEs. The problem is neither es nor localEs has both of these effects. From what I can see, none of the (un)lifting operations quite fit.

In terms of usage, I essentially have:

runHardware hardware do
  runEventWriter job1 j do
    ..

  runEventWriter job2 k do
    ..

though in reality these are really two separate job queues.

From a high-level, my goal is to have:

• Both job queues have their own EventWriter
• Both job queues share the same interpterer for Hardware.

If this is still confusing, let me know and I can try and put a minimal example together.

[ocharles]

My current solution is:

Change the type of routeMover to:

routeMover :: (EventWriter :> es, IOE :> es') => (forall a. Eff es' a -> Eff es a) -> HW.Hardware -> RouteMover -> Eff es ()

Then I can do:

      WithResizedMoverAt moverId targetLocation newSize k ->
        localSeqUnlift env \unlift ->
          localSeqLift env \lift ->
            ..
                unlift $ routeMover
                  lift
                  hw
                  RouteMover

A bit ugly, and a shame I had to change routeMover, but it does work.

[arybczak]

Hmm, that's an interesting situation.

I think #196 is a solution, right? With localSeqHandle (name subject to change, suggestions welcome 😛 ) You can capture IOE in the handler environment and "graft" it on top of localEs.

[ocharles]

I haven't had a chance to check, but yea, that looks perfect and was what I had in mind in terms of an implementation (though I wasn't brave enough to implement it 😅). No idea on the name I'm afraid!

[arybczak]

Ok, I merged the PR 🙂