Coroutine with StateT and ST and IO

Question

There are some problems with the monad group that I am trying to combine.

I use monad-coroutine , state, and lens (since I have a deeply nested state).

I had an initial approach when there was a working solution. The main thing here is that I can request execution of IOtasks outside of Coroutine.

{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleInstances         #-}
{-# LANGUAGE MultiParamTypeClasses     #-}
{-# LANGUAGE UndecidableInstances      #-}

module Main where

import           Control.Monad.Coroutine      (Coroutine(..), suspend, resume)
import           Control.Monad.State          (State, MonadState, MonadIO)
import           Control.Monad.State          (lift, get, put, liftIO, runState)
import           System.Environment           (getArgs)

type MyType = Coroutine IORequest (State MyState)

instance (MonadState s m) => MonadState s (Coroutine IORequest m) where
    get = lift get
    put = lift . put

io :: MonadIO m => IO a -> m a
io = liftIO

data IORequest x = forall a. RunIO (IO a) (a -> x)

instance Functor IORequest where
    fmap f (RunIO x g) = RunIO x (f . g)

data MyState = MyState { _someInt :: Int }

initialState :: MyState
initialState = MyState 1

request :: Monad m => IO a -> Coroutine IORequest m a
request x = suspend (RunIO x return)

myLogic :: MyType [String]
myLogic = do
    args <- request (io getArgs)
    request (io (print args))
    -- do a lot of useful stuff here
    return args

runMyType :: MyType [String] -> MyState -> IO ()
runMyType logic state = do
    let (req, state') = runState (resume logic) state
    case req of
        Left (RunIO cmd q') -> do
            result <- cmd
            runMyType (q' result) state'
        Right _ -> return ()

main :: IO ()
main = runMyType myLogic initialState

Now, at some point, a simple state is not enough, and I need ST. I started trying to get STinside StateT, but for some reason I can’t figure out how to handle IOoutside coroutine correctly . Is there any way to come up with a similar one runMyTypewhen changing Coroutine?

type MyType s = Coroutine IORequest (StateT (MyState s) (ST s))

initialState :: ST s (MyState s)
initialState = do
    a <- newSTRef 0
    return (MyState a)

, , s Couldn't match type ‘s’ with ‘s2’ .. , - ? ?

, : MyType s :

type MyType = forall s. Coroutine IORequest (StateT (MyState s) (ST s))