Freer Monads, More Extensible Effects (2015) [pdf]
Mood
thoughtful
Sentiment
neutral
Category
tech
Key topics
Functional Programming
Haskell
Monads
Extensible Effects
A PDF paper discussing Freer Monads and extensible effects in Haskell.
Snapshot generated from the HN discussion
Discussion Activity
Active discussionFirst comment
3h
Peak period
15
Day 1
Avg / period
15
Based on 15 loaded comments
Key moments
- 01Story posted
Nov 20, 2025 at 9:56 AM EST
3d ago
Step 01 - 02First comment
Nov 20, 2025 at 12:32 PM EST
3h after posting
Step 02 - 03Peak activity
15 comments in Day 1
Hottest window of the conversation
Step 03 - 04Latest activity
Nov 20, 2025 at 8:13 PM EST
3d ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
The acknowledgement section on that GitHub README mentions this paper.
The ecosystem is massive.
Cons: TypeScript is a great type system but requires some investment to get the best out of it, it's also very verbose.
Pros: you have access to the entirety of the TypeScript ecosystem.
* Polysemy: https://hackage.haskell.org/package/polysemy
* effectful: https://hackage.haskell.org/package/effectful
* Bluefin: https://hackage-content.haskell.org/package/bluefin/docs/Blu...
[Disclosure: Bluefin in my effect system]
`eff` is based on delimited continuations (which Alexis had to build into GHC), it is not using `Freer`. If you want to look at an effect system in Haskell that actually has been used in production AND is based on this paper then look at `freer-simple`: https://hackage.haskell.org/package/freer-simple
No it is not high performance, but neither are any other Haskell effect systems and performance is relative to your problem domain. It also has the benefit of being implemented very similarly to Oleg's paper making it a lot easier to learn from then most other options.
This is not true. IO-wrapper effect systems (in practice, effectful or Bluefin) have as good performance as Haskell's IO monad, that is to say as good as you can get in Haskell.
that said, your library is really cool. : )
https://koka-lang.github.io/ https://effekt-lang.org/
Frank is pretty old now but perhaps a simpler implementation: https://github.com/frank-lang/frank
As a user, I think effect libraries in Haskell trade off between five main constraints:
* Typelevel wizardry
* Boilerplate
* Performance
* Ability to handle "higher-order" effects (e.g., `bracket`)
* Safety (e.g., not accidentally leaking effects beyond their scope)
The most compelling libraries I've seen from the industrial perspective are the "IO-wrapper" libraries like `cleff`, `effectful`, and `bluefin`. These libraries tend to give good performance, can handle higher-order effects, but trade off a little safety to get the typelevel stuff down a bit. Of these, I currently favour `effectful` but am keeping an eye on `bluefin` (which is very close to `effectful` but with explicit handle-passing). The explicit handle-passing in `bluefin` seems to get the typelevel down a bit more in exchange for asking the user to write a little more boilerplate to explicitly pass handles around.
14 more comments available on Hacker News
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.