A neat fact about foldr on lists, unlike foldl, is that it actually passes control flow entirely to the accumulating function on each fold step. That means you can use foldr to implement arbitrary traversals of lists, including foldl' or list traversals that exit early. See https://github.com/quchen/articles/blob/master/useful_techni...
In Differences Between `Foldl` and `Foldr`quchen
articles
Haskell2013–2026
quchen / articles
articles
Miscellaneous articles. The readme is the table of contents.
19Distinct people
22Mentions
0Explicit recommenders
1.3KGitHub stars
What to know before exploring
What it is
Miscellaneous articles. The readme is the table of contents.
GitHub
Where it is used
No documented product use was verified in the last source check.
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
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 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 year22 dated mentions
Observed mentions: 2013-08-12 08:57:42 UTC to 2026-10-05 12:56:39 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 |
|---|---|---|---|---|---|
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 3 | 3 | 0 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 3 | 2 | 1 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 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 | 1 | 0 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 1 | 1 | 0 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 1 | 1 | 0 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 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
Quchen's articles
This repository is filled with articles I have written and needed online for
various reasons. Below is a short summary of the articles available publically.
The repository may contain files not mentioned below, in which case they're
probably unfinished or otherwise not worth reading at this point.
Haskell related
General, tutorials
Algebraic blindness is about how algebraic data types
sometimes make Boolean Blindness even more complex.
The build function explained, which is an important piece in a
popular optimization technique
The Cont monad explained
Some lazy IO pitfalls
The fix function, one possible fundamental building block of
recursion
Frequently Brought Up Topics in Freenode's #haskell
channel
Basic Haskell functions written in easily comprehensible
notation. Nice for explaining e.g. sequence.
What I thought was cool about Haskell some time ago. I should
update this one day.
Equality table of Haskell values. (live version)
Created in a time where it seemed to be en vogue to create tables for the ==
operator in various languages. Spoiler, it's terribly boring, because it
should be.
How to fix, or avoid fixing, certain warnings
My Haskell code style and the rationale behind it
Informal description of class instances gives non-technical
descriptions of various common class instances.
An extensive tutorial on the Hindley-Damas-Milner type inference algorithm
Lens infix operators cheat sheet provides an overview of what
the individual symbols in infix operators of the lens library stand
for.
Löb/Möb is about an interesting, simple, complicated and quirky
recursive function.
Reader instance derived shows how to write the usual Reader
monad instance starting from something readable and comprehensible.
The second Functor law is redundant
Tag, don't type is about avoiding type synonyms, and
using Data.Tagged instead.
How to write unmaintainable Haskell, inspired by
How to write unmaintainable code
Useful techniques I've found over the years and haven't seen
described elsewhere
Write yourself a Brainfuck in an hour implements a very simple
Brainfuck interpreter in Haskell, with plenty of room to go on
afterwards.
Make macros mean something – readable backwards compatibility with
CPP talks about how to define readable macro synonyms
for writing backwards compatible libraries.
zipWith const is my favorite Haskell function
Proposals
Applicative-Monad proposal (AMP) is the original text of the 2013
Applicative-Monad proposal, which was the starting point for Applicative
becoming a superclass of Monad in GHC 7.10.
Rules for typeclass laws wasn't proosed yet
The MonadFail proposal is a proposal similar to the AMP, with the goal of
removing fail from the Monad typeclass.
Original text
Update after one week of discussion.
Read the full README on GitHubWhat Hacker News says
22 sourcesYes, there are some cool solutions using laziness that aren't immediately obvious. For example, in 2015 and 2024 there were problems involving circuits of gates that were elegantly solved using the Löb function:
https://github.com/quchen/articles/blob/master/loeb-moeb.md
In Advent of Code 2025Löb and Möb: Loops in Haskell (2013)
91 points · Open discussionLöb and möb: strange loops in Haskell (2015)
153 points · Open discussionLöb and möb: strange loops in Haskell
4 points · Open discussionAh individual control of a large array of reactors is trickier. I think the bang-bang controller with keeping all reactors synchronized has good legs, but it stops scaling well at some point. If the buffers become the limitation and you don’t want to run all of the reactors synchronized then a PID controller would be a good pick. The output value would choose how far
up the row of reactors you enable. If you could force max load on will, then loop tuning is a possibility.
To maintain the simultaneous reactor bonus, you would want to keep the fueling cycle synchronized and just adjust which reactors are enabled each cycle. This can be done with a clock that has a period of one fuel cycle.
One interesting thing is that due to the nature of reactors, you will have higher efficiency in running more reactors if your buffer does not run ou
Read the rest
t. It might be possible to eek out a little more efficiency if you fall back to a bang-bang controller in low load scenarios (making sure the threshold and number of reactors used won’t overfill the buffer, which is practically unlikely in low load scenarios). I would have to experiment with this a bit more to see if it’s reasonable to capture more efficiency.
All of this is practically orthogonal to the standard players perception of efficiency, but I find it fun.
https://en.wikipedia.org/wiki/PID_controller
https://github.com/quchen/articles/blob/factorio/factorio/ci...
Löb and möb: strange loops in Haskell (2013)
86 points · Open discussionAlgebraic blindness: Boolean blindness for often type systems
1 points · Open discussionIn haskell passing a bool is still considered an anti pattern, it's called boolean blindness. This is mostly because bool's don't carry semantic information.
Same goes for `Optional<T>` in an argument position, though https://github.com/quchen/articles/blob/master/algebraic-bli...
In Anti-If: The missing patterns (2016)How to write unmaintainable Haskell code
1 points · Open discussionUndefined is not Haskell's null
2 points · Open discussionThe point of tail recursion is using constant space, not constant stack space (does Haskell even have a stack?) Anyways, the Haskell spec allows foldl' to use linear space just like its lazier counterparts. The fact that it uses constant space is an implementation detail of GHC. Reference: https://github.com/quchen/articles/blob/master/fbut.md#seq-d...
Structural recursion always terminates in SML. Supporting infinite/cyclic values in algebraic data types is a misfeature, and they are trivial to rule out without using a totality checker. Heck, I can implement a guaranteed finite linked list in Java :-)
I think something like MLKit would be a more promising start for implementing a safety critical system. Tail and structural recursion actually work there, and it statically replaces most uses of GC with region inference. Though it's still a
Read the rest
very long shot, I'd prefer something more proven.
Showing the 15 most recent of 22 sources. Enable JavaScript to search and browse every indexed mention.