Generic monad functions with SeqT

Repro

let test_b : SeqT<ReaderT<Input, State<MenuState, seq<MenuMessage>>>> =
    monad.plus' {
        let! read_fail_a = ask
        let! state_fail_a = get
        
        let! read_fail_b = lift ask
        let! state_fail_b = lift get
        
        let! read_success_c = SeqT.lift ask
        let! state_success_c = SeqT.lift get
        
        return Exit
    }

Actual behavior

c works as expected, but a and b result in the following compilation error:

Type constraint mismatch when applying the default type 'obj' for a type inference variable.
No overloads match for method 'op_GreaterGreaterEquals'. 
Known return type: ReaderT<Input,State<MenuState,seq<MenuMessage>>>
Known type parameters: < obj , (seq<seq<MenuMessage>> -> ReaderT<Input,State<MenuState,seq<MenuMessage>>>) >

Expected behavior

I expected to be able to use generic functions like ask and get with SeqT without lifting, but maybe I’m misunderstanding how deep my nested monads are or I’ve set the wrong type parameters or something like that? Maybe I can’t mix side effects and monad.plus?

[gusty]

That’s fine. One more detail: I see you’re using a strict monad.plus, by writing monad.plus', but not sure if you read this section of the docs.

There it states:

For layered monads (monad transformers) the general rule is: the monad is strict unless at least one of its constituent types is lazy, in that case the whole monad becomes lazy.

Following. there is a small snippet that helps you when in doubt whether the monad is strict or not.

In your sample, both ReaderT and State are lazy, so even if this version of SeqT is strict (unlike the ideal implementation I mentioned in my previous comment), the whole combination should be a lazy one.

[harrisse]

Thanks, I am mainly looking for the syntactic sugar to return multiple elements (or ()) which SeqT seems to provide well enough. I was able to solve my problem with SeqT.lift ask and State.get |> ReaderT.lift |> SeqT.lift for ask and get respectively.