mtl-style-example VS effectful

Re: effects libraries, it's probably worth starting with e.g. https://www.fpcomplete.com/blog/2017/06/readert-design-pattern/ https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html https://github.com/lexi-lambda/mtl-style-example if you're just getting familiar with the ecosystem. I'll add, anything written by the the people I linked to in this comment is probably worth reading as well.

Personally, it felt to me like, once I really understood monad transformers (https://hackage.haskell.org/package/transformers) and mtl (https://hackage.haskell.org/package/mtl), the reasons they both exist and how they are distinct, how you use them generally and what common patterns are around structuring your app (see e.g. https://github.com/lexi-lambda/mtl-style-example and the 3-layer-cake link someone else provided here for two), a lot of stuff in the ecosystem suddenly became comprehensible and useful to me, in a practical, "real world" way. In fact I'd go so far as to assert that getting comfortable with mtl in particular is the biggest single step you can take to being able to build arbitrarily useful real-world apps that are no longer toys.

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

effectful got rid of all issues I listed (I expanded a little on it here).

There is also a long document on Issues with the Transformer/mtl library.

cats-effects -> https://github.com/haskell-effectful/effectful

I think ReaderT over IO or an algebraic effect system that uses it under the hood like effectful is the way to go. However, you mentioned redux, so perhaps you'd be comfortable with organizing things using TEA (the elm architecture)? You would have actions that different components listen to , and your async stuff could be handled using subscriptions.

API for basic usage is very similar, but things quickly go south once you want to use higher order effects (i.e. effects that make use of the m type parameter). A lot of things then become very hard to write due to complex types or outright impossible (this issue is a good example - a reasonable thing to do that is very straightforward to write with effectful, apparently impossible to do with polysemy).

> 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-effectful/effectful

Also note that Polysemy has some really bad performance characteristics. Don't know how much of a problem it could be at such a small scale, but if you need to use an effect system, maybe something faster like effectful would be a better choice.

See also https://github.com/haskell-effectful/effectful/issues/99.

FYI, transformers and mtl have several subtle traps. You can read about them here.