How to integrate/lift/inject custom monad stack with HSpec?

Question

Context

I have some monadic functions for an interpreter that I'm trying to test with HSpec. They run with the following monad stack:

type AppState = StateT InterpreterState (ExceptT Events IO)
type AppReturn a = Either Events (a, PState)

runApp :: AppState a -> IO (AppReturn a)
runApp f = runExceptT (runStateT f new)

Here's an example of a simple one:

mustEvalExpr :: Expr -> S.AppState (S.Value)
mustEvalExpr e = do
    val <- evalExpr e
    case val of
        Just val' -> return val'
        Nothing   -> throw $ S.CannotEval e

The problem is that HSpec has its own context (IO ()), so I have to translate between the two contexts.

Current Approach

I'm using HSpec, and I wrote a transformer function to get a runApp context from within the HSpec context.

-- imports omitted

extract :: S.AppReturn a -> a
extract st = case st of
    Right (a, _) -> a
    Left ev      -> throw ev

run :: (S.AppReturn a -> b) -> S.AppState a -> IO b
run extractor fn = do
    state <- S.runApp fn
    return $ extractor state

So my Spec looks like this:

spec :: Spec
spec = do
    describe "mustEvalExpr" $ do
        let badExpr = D.VarExpr $ D.Id "doesntExist"
            goodExpr = D.IntExpr 1
            val = S.IntValue 1

        it "should evaluate and return expression if its a Just" $ do
            (run extract $ do
                I.mustEvalExpr goodExpr
                ) >>= (`shouldBe` val)

        it "should throw error if it gets a Nothing" $ do
            (run extract $ do
                I.mustEvalExpr badExpr
                ) `shouldThrow` anyException

Question

Is this the best I can do? I feel like run extract $ do is fine, and I think it's good to be explicit when things are complicated.

But I was wondering if there was a way I can integrate with HSpec, or if there's a best-practice for this problem that doesn't require custom code?