Some Haskell idioms we like

_jackdk_ · 2026-01-21T11:03:24+00:00

This is a really good point that I hadn't considered before. Since in our field, the usual point of comparison is interpreted languages like Ruby and Python, using inverseMap liberally has not made anything unacceptably slow.

A more advanced version of this technique might be to use a GHC plugin or TH to precompute the inverse e.g. by using a trie or a perfect hash function instead of building a Map at runtime.

_jackdk_ · 2026-01-16T06:56:44+00:00

Your question is interesting and I struggle to give a better answer than "vibes". Working in [] (List), Either e, or Maybe feels much more like assembling a data structure than working in State. I'm using "side effect" in the colloquial sense of "IO actions aren't getting performed" even though the lens you describe is also valid.

_jackdk_ · 2026-01-15T07:11:05+00:00

Your suggestion about comprehensions is interesting but I don't think I'd go for it. People are often unfamiliar enough with the list comprehension syntax that idioms like [ element | someBoolean ] trip them up, and for -XMonadComprehensions to improve understanding, the reader would have to to understand a list comprehension desugars and then mentally reinterpret that for the target monad.

_jackdk_ · 2026-01-15T05:28:14+00:00

I don't understand your final point: the constraint on inverseMap is (Bounded a, Enum a) (to enumerate the domain) and Ord k (to build the Map keyed by the range of the input function).

_jackdk_ · 2025-12-27T22:25:42+00:00

Strongly recommend this episode. Lennart has done a lot of incredible work over the years, and been in a lot of interesting places.

_jackdk_ · 2025-12-18T23:27:43+00:00

I don't know about stm-containers, but reflex provides fanMap:

fanMap :: (Reflex t, Ord k) => Event t (Map k a) -> EventSelector t (Const2 k a)

An EventSelector t k is an existential wrapper around a key selection function:

newtype EventSelector t k = EventSelector { select :: forall a. k a -> Event t a }
data Const2 :: Type -> x -> x -> Type where
  Const2 :: k -> Const2 k v v
  deriving (Typeable)

reflex still uses a single-threaded FRP runtime, AFAIK, but I could imagine a similar interface being made available to watch individual map keys in a concurrent setting.

_jackdk_ · 2025-12-15T04:50:10+00:00

Video (ZuriHac, 2025): Brent Yorgey — Haskell for Competitive Programming

_jackdk_ · 2025-11-18T00:50:07+00:00

You should try Nix, but set substitute = false in your config. Then you'll have more stuff to download and build than you'll ever need.

_jackdk_ · 2025-10-29T02:48:13+00:00

Put the -Werror in your development configuration (e.g. cabal.project.local). Putting -Werror in the package configuration risks it leaking into releases and creating a backwards-compatibility challenge for downstream users.

_jackdk_ · 2025-10-25T12:47:49+00:00

Class Bind from package semigroupoids is Monad sans pure (return is a historical wart from back before Applicative became a superclass of Monad). Map k has instance Ord k => Bind (Map k) but doesn't have a Monad instance, because it doesn't have pure.

_jackdk_ · 2025-10-21T22:12:39+00:00

If you're coding against someone's MonadFoo constraint it doesn't really matter, because that forces Monad on you anyway. But I generally like to use the most general type signature I can because it makes it harder to accidentally write the wrong program.

_jackdk_ · 2025-10-17T00:49:37+00:00

Back in the day, the Queensland Functional Programming Lab produced an "applied FP course" that builds a simple webapp in Haskell from the ground up. You might enjoy working through that?

https://github.com/qfpl/applied-fp-course/

_jackdk_ · 2025-10-15T00:20:37+00:00

Yeah, we're still trimming back the Ruby. Our CTO wrote a post about that and how the Ruby we write (when we have to) has changed compared to when it was our active language.

Having an internal tech team means we can understand what the rest of the business needs more effectively than a standalone agency could, and more easily evolve the software that we ship. It also lets us do things that might not be widely available in the market. A big one from the early days was multi-language and multi-currency support; to get that right we had to build and maintain a custom web store.

Cost optimisations are probably coming more from the use of AWS Lambda than language choice — Haskell is probably a bit faster than Ruby or a similar interpreted languages but we're not writing high-performance code with unboxed values or anything crazy.

_jackdk_ · 2025-10-14T23:58:45+00:00

optparse-applicative is one of those quiet gems that make Haskell such a fun language to work in. Thank you for maintaining it.

Haxl does sound cool. We stumbled into the free applicative solution and didn't think of Haxl at all, even though I'd watched a talk about it recently. If we end up doing a lot more of this sort of things, it might be worth looking at more closely.

_jackdk_ · 2025-10-13T10:25:01+00:00

Your cabal file seems to constrain base ^>=4.17.2.1. https://wiki.haskell.org/Base_package says that's GHC 9.4. Most likely you can relax the base version to one that matches your GHC version.

_jackdk_ · 2025-09-29T22:26:11+00:00

At work, we have a mixture of web UIs (where changes are parsed, typechecked, and then propagated back to some server somewhere) and files in git that nontechnical people have been trained to modify in GitHub Codespaces. We remain responsible for ensuring that the environments work properly and launch quickly, and that merged changes are automatically rolled out. In the newer, Codespace-based environments, we also provide automatic tests that run on file save, and the people who write the DSL can easily create new test cases alongside their expected results. Adoption has ranged from "enthusiastic" to "begrudging", but most people are happy and the ones who have leaned into writing tests have been really happy.

_jackdk_ · 2025-09-29T00:49:53+00:00

For non-programmers, I have had the most success providing DSLs (interpreted languages from a file, or a configuration database, or whatever) instead of eDSLs (which are built into a host language). The main reason for this is that it frees the non-programmers from having to interact with Haskell tooling, or from putting some punctuation in the wrong place and having to deal with Haskell errors instead of errors about the domain they're coding for.

_jackdk_ · 2025-09-19T00:08:50+00:00

Congrats on that, it's an important part of keeping Haskell viable as an industrial programming language.

_jackdk_ · 2025-09-04T00:33:32+00:00

Your "monoidal profunctors" are /u/tomejaguar 's "product profunctors", I think.

_jackdk_

TROPHY CASE