ghc-proposals VS effectful

> I think Haskell needs a way to graduate (or retire) language extensions

https://github.com/ghc-proposals/ghc-proposals/pull/601

Additionally, while this proposal is focused on the simple implementation and so in the current proposal or patterns do not bind any variables as per #522, if we do get settled on syntax and then later wish to expand to allow binding variables as in #43, then the syntax is again clean and discoverable.

Yeah, a relatively natural thing would be to be able to opt-in to having the HasField instances be available in all contexts. The (not yet implemented, but accepted) "Modifiers" GHC proposal might be nice for that.

The local modules proposal imo is excellent as-is.

Why would you drop TypeFamilies? It seems fairly popular, given that it was just one vote short of getting added to GHC2021. Do you consider it a less-ideal compromise, that is subsumed by your second proposal (Core with GRTT)?

as syntax is contentious a topic as ever, David (the main proposal author) and I would like to invite you to give your input on https://github.com/ghc-proposals/ghc-proposals/pull/585, where we propose to change the syntax of the accepted proposal #522 introducing Or patterns. In particular, we'd like to know

This looks great, congratulations on completing it! I assume you didn’t get an opportunity to evaluate the delimited continuations based eff library? It would’ve been nice to see Cont included as one of the effects covered, though perhaps not available in all the systems you looked at? Maybe some future work.

I do hope qualified exports are available someday: https://github.com/ghc-proposals/ghc-proposals/pull/283

Right. Being able to disable "custom type warnings" at use sites was part of an earlier proposal (https://github.com/ghc-proposals/ghc-proposals/pull/454) but it ended up being shelved.

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.