How can I lend multiple effects?

[ocharles]

I have the following:

data MoverAllocator :: Effect where
  WithMover :: MoverToken -> Eff (Mover : es) r -> MoverAllocator (Eff es) r

data Mover :: Effect where
  WithMoverAt :: Point V2 Int -> m a -> Mover m a

When I go to implement this, I have:

runMoverAllocator ::
  (Concurrent :> es, IOE :> es) =>
  MoverFleet -> Eff (MoverAllocator : es) a -> Eff es a
runMoverAllocator moverFleet = reinterpret runMoverRouting \localEnv -> \case
  WithMover moverToken k ->
    localSeqUnlift localEnv \unlift -> do
      localSeqLend @IOE localEnv \runIOE -> do
        unlift $
          runIOE $
            runConcurrent $
              interpret
                (withMoverHandler (index s moverId))
                (inject k)
  where
    withMoverHandler ::
      (SharedSuffix es handlerEs, IOE :> es, Concurrent :> es, MoverRouting :> es) =>
      MoverState ->
      LocalEnv localEs handlerEs ->
      Mover (Eff localEs) a ->
      Eff es a
    withMoverHandler s localEnv = \case
      WithMoverAt p k ->
        localSeqUnlift localEnv \unlift -> do
          routeMover s.moverId p do
            unlift k

Note that in withMoverHandler, for my WithMoverAt implementation I'm calling something in an internal MoverRouting effect:

data MoverRouting :: Effect where
  RouteMover ::
    { moverId :: MoverId
    , target :: Point V2 Int
    , m :: Eff es a
    } ->
    MoverRouting (Eff es) a

This effect is available in runMoverAllocator - notice that I'm doing reinterpret runMoverRouting. However, I don't seem to actually be able to use that, because I can only lend a single effect. In this case, I need to lend IOE so that I can use localSeqUnlift. If I try and lend the MoverRouting effect, I get:

  WithMover moverToken k ->
    localSeqUnlift localEnv \unlift -> do
      localSeqLend @IOE localEnv \runIOE -> do
        localSeqLend @MoverRouting localEnv \runMoverRouting -> do
          -- Block until this acqusition is complete.
          moverId <- atomically moverToken.acquire
          s <- get @(Movers MoverState)
          unlift $
            runIOE $
              runMoverRouting $
                runConcurrent $
                  interpret
                    (withMoverHandler (index s moverId))
                    (inject k)

which doesn't type check:

lib/CircuitHub/PNP/Mover/V2.hs:277:15: error: [GHC-25897]
    • Couldn't match type ‘localEs’ with ‘IOE : localEs’
      Expected: Eff (IOE : localEs) a1
        Actual: Eff localEs a1
      ‘localEs’ is a rigid type variable bound by
        a type expected by the context:
          Effectful.Internal.Monad.EffectHandler
            MoverAllocator (State (Movers MoverState) : es)
        at lib/CircuitHub/PNP/Mover/V2.hs:(225,54)-(282,2)

I understand this is a very convoluted set up and I have ways to change, but it does nonetheless seem to highlight something that's currently impossible.

[ocharles]

My fix for this is currently to define:

extendLocalEnv
  :: (e :> es, SharedSuffix es handlerEs)
  => LocalEnv localEs handlerEs
  -> Eff es (LocalEnv (e : localEs) handlerEs)
extendLocalEnv (LocalEnv les) = unsafeEff $ \es -> LocalEnv <$> copyRef es les

Then I can do:

  WithMover moverToken k -> do
    localEnv <- extendLocalEnv @IOE localEnv
    localEnv <- extendLocalEnv @MoverRouting localEnv

    localSeqUnlift localEnv \unlift -> do
      unlift $
        runConcurrent $
          interpret
            (withMoverHandler (index s moverId))
            (inject k)

But I have no idea how safe that is!

[arybczak]

As a workaround it's fine ;) It's safe.

[ocharles]

Phew! I'll stick with this for now then

[arybczak]

Oh, I considered lending multiple effects when adding these functions, but didn't test it and so didn't realize that scoped runners are constrained to localEs, so you won't be able to stack them, oops.

I guess I'll have to change this to accept a list of effects to borrow/lend, so you can say localSeqLend @[IOE, MoverRouting] and get both at the same time.

As for this particular instance, your MoverAllocator is Provider_ MoverToken Mover, so if you use it instead of defining an effect, this should work:

data MoverToken

data Mover :: Effect where
  WithMoverAt :: Int -> m a -> Mover m a
type instance DispatchOf Mover = Dynamic

data MoverRouting :: Effect where
  RouteMover :: Int -> m a -> MoverRouting m a
type instance DispatchOf MoverRouting = Dynamic

runMoverRouting :: Eff (MoverRouting : es) a -> Eff es a
runMoverRouting = undefined

runMover :: {- ... => -} MoverToken -> Eff (Mover : es) a -> Eff es a
runMover token action = do
  -- Block until this acqusition is complete.
  -- moverId <- atomically moverToken.acquire
  -- s <- get @(Movers MoverState)
  reinterpretWith runMoverRouting action $ \env -> \case
    WithMoverAt p k -> localSeqUnlift env $ \unlift ->
      send $ RouteMover p (unlift k)

And then you can use runProvider runMover instead of runMoverAllocator (I skipped MoverFleet because I don't know where it's used) and WithMover then becomes provideWith_ @Mover.

[ocharles]

I guess I'll have to change this to accept a list of effects to borrow/lend, so you can say localSeqLend @[IOE, MoverRouting] and get both at the same time.

Yea, that would be fine I think!

As for this particular instance, your MoverAllocator is Provider_ MoverToken Mover, so if you use it instead of defining an effect, this should work:

I had to drop a bunch of details for this example, but it's a bit more complicated and won't work with Provider. For one, I should only have a single runMoverRouting call that is shared by all runMovers, but it's also a fairly "internal" effect that shouldn't be visible to downstream users (it's bundled into runMoverAllocator).

But thanks for the suggestion - I did think about Provider but then promptly forgot. I'm still iterating on this design, so maybe it will work in the end!

[arybczak]

Fixed by #234.