Compare with the prior art of N+1 queries of 2014:
https://github.com/facebook/Haxl/blob/main/example/sql/readm...
In Solving the 1+N Query Problemmeta
Haxl
Haskell2014–2026
meta / Haxl
Haxl
A Haskell library that simplifies access to remote data, such as databases or web-based services.
24Distinct people
25Mentions
0Explicit recommenders
4.4KGitHub stars
What to know before exploring
What it is
A Haskell library that simplifies access to remote data, such as databases or web-based services.
GitHub
Where it is used
The source check is incomplete. Verified examples will appear here.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- meta/flow · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year25 dated mentions
Observed mentions: 2014-06-10 18:25:31 UTC to 2026-08-25 16:50:14 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Haxl
Haxl is a Haskell library that simplifies access to remote data, such
as databases or web-based services. Haxl can automatically
batch multiple requests to the same data source,
request data from multiple data sources concurrently,
cache previous requests,
memoize computations.
Having all this handled for you behind the scenes means that your
data-fetching code can be much cleaner and clearer than it would
otherwise be if it had to worry about optimizing data-fetching. We'll
give some examples of how this works in the pages linked below.
There are two Haskell packages here:
haxl: The core Haxl framework
haxl-facebook (in https://github.com/facebook/Haxl/tree/master/example/facebook): An (incomplete) example data source for accessing the Facebook Graph API
To use Haxl in your own application, you will likely need to build one or more
data sources: the thin layer between Haxl and the data that you want
to fetch, be it a database, a web API, a cloud service, or whatever.
There is a generic datasource in "Haxl.DataSource.ConcurrentIO" that
can be used for performing arbitrary IO operations concurrently, given
a bit of boilerplate to define the IO operations you want to perform.
The haxl-facebook package shows how we might build a Haxl data
source based on the existing fb package for talking to the Facebook
Graph API.
Where to go next?
The Story of Haxl
explains how Haxl came about at Facebook, and discusses our
particular use case.
An example Facebook data source walks
through building an example data source that queries the Facebook
Graph API concurrently.
Fun with Haxl (part 1)
Walks through using Haxl from scratch for a simple SQLite-backed
blog engine.
The N+1 Selects Problem explains how Haxl
can address a common performance problem with SQL queries by
automatically batching multiple queries into a single query,
without the programmer having to specify this behavior.
Haxl Documentation on
Hackage.
There is no Fork: An Abstraction for Efficient, Concurrent, and Concise Data Access, our paper on Haxl, accepted for publication at ICFP'14.
Contributing
We welcome contributions! See CONTRIBUTING for details on how to get started, and our Code of Conduct.
License
Haxl uses the BSD 3-clause License, as found in the LICENSE file.
Read the full README on GitHubWhat Hacker News says
25 sourcesName-dropped both the N+1 problem and Haskell without mentioning Haxl.
Take a look at last decade's solution to this problem:
https://github.com/facebook/Haxl/blob/main/example/sql/readm...
In Abstraction boundaries are optimization boundariesFor some reason everyone likes to talk about Monads, but really the other types here are just as interesting. For example, Applicatives are less dynamic than Monads in that you can't `flatMap`/`bind` to decide on the "next" thing to evaluate based on the previous value, but in exchange you get a "static" tree (or graph) of Applicatives that lends itself much better to static analysis, optimization, parallelism, and so on.
IIRC Haxl (https://github.com/facebook/Haxl) uses Applicatives to optimize and parallelise remote data fetching, which is hard to do with Monads since those are inherently sequential due to the nature of `flatMap`/`bind`. My own Mill build tool (https://mill-build.org/) uses an applicative structure for your build so we can materialize the entire build graph up front and choose how to parallelize it, query it, or otherw
Read the rest
ise manipulate it, which is again impossible with Monads since the structure of a Monad computation is only assembled "on the fly" as the individual steps are being evaluated. "Parallel Validation" where you want to aggregate all failures, rather than stopping at the first one, is another common use case (e.g. https://hackage.haskell.org/package/validation or https://typelevel.org/cats/datatypes/validated.html)
Monads seem to have this strange aura around them that attracts certain kinds of personalities, but really they're just one abstraction in a whole toolkit of useful abstractions, and there are many cases where Applicative or some other construct are much more suited
Looks like it has become abandonware, or at least the component they open sourced. Oh well, such is life in the Haskell ecosystem. https://github.com/facebook/Haxl
In Haskell is Useless (2011) [video]This vaguely reminds me of Jefferson's "Virtual Time" paper from 1985[1]. The underlying idea at the time didn't really take off because it required, like Zookeeper, a greenfield project: except that it kinda doesn't and today you could imagine instrumenting an entire Linux syscall table and letting any Linux container become a virtual time system -- but Linux didn't exist in 1985 and wouldn't be standard until much later.
So Jefferson just says, let's take your I/O-ful process, split it a message-passing actor model, and monitor all the messages going in and coming out. The messages coming out, they won't necessarily do what they're supposed to do yet, they'll just be recorded with a plus sign and a virtual timestamp, and by assumption eventually you'll block on some response. So we have a bunch of recorded message timestamps coming in,
Read the rest
we have your recorded messages going out.
Well, there's a problem here, which is that if we have multiple actors we may discover that their timestamps have traveled out-of-order. You sent some message at t=532 but someone actually sent you a message at t=231 that you might have selected instead of whatever you actually selected to send the t=532 message. (For instance in the OS case, they might have literally sent a SIGKILL to your process and you might not have sent anything after that.) That's what the plus sign is for, indirectly: we can restart your process from either a known synchronization state or else from the very beginning, we know all of its inputs during its first run so we have "determinized" it up past t=231 to see what it does now. Now, it sends a new message at say t=373. So we use the opposite of +, the minus sign, to send to all the other processes the "undo" message for their t=532 message, this removes it from their message buffer: that will never be sent to them. And if they haven't hit that timestamp in their personal processing yet, no further action is needed, otherwise we need to roll them back too. Doing so you determinize the whole networked cluster.
The only other really modern implementation of these older ideas that I remember seeing was Haxl[2], a Haskell library which does something similar but rather than using a virtual time coordinate, it just uses a process-local cache: when you request any I/O, it first fetches from the cache if possible and then if that's not possible it goes out, fetches the data, and then caches it. As a result you can just offer someone a pre-populated cache which, with these recorded inputs, will regenerate the offending stack trace deterministically.
1: https://dl.acm.org/doi/10.1145/3916.3988
2: https://github.com/facebook/Haxl
+1. The JS event loop auto-monad-izing Promises into Haxl [1]-esqe trees of implicitly-batched loads has been a big win for us building on JavaScript/TypeScript.
If I had to move to another language, I'd really want to find a "powered by the event loop / dataloader" framework, i.e. Vert.x for Java.
Also, per dataloader, a shameless plug for our ORM that has dataloader de-N+1-ing built natively into all object graph traversals:
https://joist-orm.io/docs/goals/avoiding-n-plus-1s
[1]: https://github.com/facebook/Haxl
In Ban 1+N in DjangoYou mean, Haxl? [1] But AFAIK only a few devs are involved for the development.
[1] https://github.com/facebook/Haxl
In I would like a job writing HaskellFacebook uses Haskell for [Haxl](https://github.com/facebook/Haxl), Standard Chartered has a their
own Haskell [compiler](https://www.reddit.com/r/haskell/comments/6im268/standard_ch...)
and a massive code base in Haskell. [Agda](https://github.com/agda/agda) and [Idris](https://github.com/idris-lang/Idris-dev)
were mostly written in Haskell as well.
In What killed Haskell, could kill Rust, tooCan't really comment on that - most of the code I use is built on the awesome Haxl[0] so we never have to worry about those things. I'm curious what other people think though
[0] https://github.com/facebook/Haxl
In What Is Good About Haskell?Facebook built Haxl[0], a library in Haskell, precisely for this use case: batching, caching and paralyzing requests against external sources.
[0] https://github.com/facebook/Haxl
In What Color is Your Function? (2015)> But until it affects day to day dev work, there's a whole set of people that aren't going to give the slightest fuck.
That's a seriously toxic attitude to have.
People are using monads and other FP concepts daily to simplify "day to day dev work" (here's an example [0].) The fact that it's more or less mainstream to write off a concept because it sounds "academic" is worryingly anti-intellectual in a profession that is allegedly based in analytical thinking.
> Can anyone here give a concrete example of a real world problem that is more cleanly solved with these changes to the Promise spec?
There are some in the linked github thread (which had to be reposted repeatedly until people actually stopped and read them, btw.) It's about being able to write DRY code that abstracts over not only promises, but anything else that forms a monad, lik
Read the rest
e arrays, optional values, and so on.
[0] https://github.com/facebook/Haxl
So which FB project still have a BSD+patents license.
I count:
* ReasonML - https://github.com/facebook/reason/blob/master/PATENTS.txt
* GraphQL - https://github.com/graphql/graphql-js/blob/master/PATENTS
* react-native - https://github.com/facebook/react-native/blob/master/PATENTS
* PlanOut - https://github.com/facebook/planout/blob/master/PATENTS
* Flow - https://github.com/facebook/flow/blob/master/PATENTS
* Haxl - https://github.com/facebook/Haxl/blob/master/PATENTS
* Flux - https://github.com/facebook/flux/blob/master/PATENTS
Just a few that I found.. Please reply if you know more project that are still BSD+PATENTS licensed.
In Relicensing React, Jest, Flow, and Immutable.jsIf you're puzzling at the connection between Facebook and Haskell, https://github.com/facebook/Haxl is the most obvious one.
In Rust as a gateway drug to HaskellHaskell has lots of large projects written in it.
Besides the ones others have mentioned, Haxl is probably one of the bigger known industry uses of it. It is used at facebook as their spam filter:
https://github.com/facebook/Haxl
If you scroll to the bottom of that github page, you can find several papers and articles that go into detail about it.
In The myth of using Scala as a better JavaThen you haven't been paying much attention to Haskell which can be forgiven because it's still pretty niche compared to Python or JS.
The best example I can give you is the Haxl project at Facebook [0].
[0] https://github.com/facebook/Haxl
In A Taste of HaskellShowing the 15 most recent of 25 sources. Enable JavaScript to search and browse every indexed mention.