effectful

Basically StateT uses Either to model either the application state or an error. So if your application throws, you lose the current state forever. They sort of painted themselves into a corner with this choice of type, there's no real way out now. This explains in more detail: https://github.com/haskell-effectful/effectful/blob/master/t... I agree loosely with what haskman above says about creating relatively bug free applications, the guard rails are so robust. But those same guard rails mean you can paint yourself into a corner that it is harder to get out of without imperative state, case in point above.

You may get answers by reading https://github.com/haskell-effectful/effectful/?tab=readme-o...

Also a much simpler alternative in my opinion to monad transformers is effectful: https://github.com/haskell-effectful/effectful Here's a talk on it: https://www.youtube.com/watch?v=BUoYKBLOOrE

> Lets say you have a huge overly-convoluted Haskell program. Somewhere deep down a call hierachy of pure functions you need to print something to the console. That is not easy to refactor. > Or vice-versa you have a huge convoluted program where everything happens inside an IO monad because at some point something is written to the console. Now you realize you dont need to write to the console. These problems are essentially completely resolved these days by a modern effect system like effectful. Basically, they allow you to do arbitrary effects deep down a call stack with minimal plumbing (you still have adjust the types, as you should: that's the point of effect tracking!) and also to remove effects, so you can easily convert between pure code and "effectful code that just so happens to do no effects". https://github.com/haskell-effec

One thing the author fails to mention, is that monads can't _annotate_ the terms. They can not replace effects in the type system, since something `putStrLn` doesn't _cause_ an effect, it _returns_ it. In a strict language, even if you have something like `putStrLn :: String -> IO ()`, you can not do `let _ = putStrLn "d" in x` and have it not print it, unless `IO` wraps the computation in a lambda, which is quite suboptimal. Hence, monads are not a replacement for effects, even if people are making things like https://github.com/haskell-effectful/effectful/.