Converting monomorphic transformers stacks into eff polymorphic effects

[eldritch-cookie]

i have a compiling proof of concept for readerT

{-#LANGUAGE UndecidableInstances,AllowAmbiguousTypes #-}
module Control.Effable(Effable(..)) where
import Effectful
import Effectful.Reader.Static
import Control.Monad.Trans.Reader(ReaderT(..),runReaderT)
import Data.Kind
import Data.Functor.Identity

type Effable ::[Effect] -> (Type -> Type) -> Constraint
class Effable es m where
  toEff :: forall a. m a -> Eff es a

instance Effable es Identity where
  toEff = return . runIdentity

instance IOE :> es => Effable es IO where
  toEff = liftIO

instance (Reader r :> es , Effable es m) => Effable es (ReaderT r m) where
  toEff ma = ask >>= (toEff . runReaderT ma)

is this useful ? because i believe it possible to do at least for StateT and WriterT
my idea would be to use this with newtypes by using

deriving newtype instance (MyMonadNewtype, OtherConstraints) => Effable es MyMonadNewtype

the main problem i see with this idea is that from a specific newtyped monad we go to a generic effect.
but i probably could make a new effect which has all the operations necessary and go from Monad transformer to Eff es

[eldritch-cookie]

instances for writerT and StateT

instance (State s :> es,Effable es m) => Effable es (StateT s m) where
  toEff ma = get >>= (toEff . runStateT ma) >>= \(a,s) -> put s >> return a

instance (Monoid w,Writer w :> es,Effable es m) => Effable es (WriterT w m) where
  toEff ma = toEff (runWriterT ma) >>= \(a,w) -> tell w >> return a

[arybczak]

is this useful ?

I'm not sure. Do I understand correctly that this is for embedding monad transformer stacks into Eff?

What's the example use case?

[eldritch-cookie]

i thought about this due to neovim-hs the idea is to use the instances defined above + deriving via to allow to embed any monad transformer stack into a Eff effect stack so yes you are correct