Planet Haskell

Well-Typed.Com: Whole project loading for Haskell IDE tooling

Fri, 04 Sep 2026 00:00:00 +0000

From Haskell Language Server 2.15.0.0 onwards, users can opt-in to loading all components of their current project up front, rather than as needed. Doing so ensures information about every module is fully available from the start, and avoids pauses to re-initialize the session when opening a file from a new component.

The feature is enabled by setting componentsLoading to "multi: whole-project" in the HLS configuration.

The next release of Haskell Debugger will load all components up front too. Debug sessions will then be able to support breakpoints from any module in the project, not just the entry point’s component.

The feature is provided by hie-bios >= 0.20 and the cradle config (hie.yaml) can be used to fine-tune the list of components to load. The new componentsToLoad field lets you list the exact targets to pick, which are otherwise the components listed in the cradle or inferred from the cabal/stack project.

Multi component sessions

Haskell Language Server has supported multi component sessions for a while, e.g. when working on a Cabal package with both a library and an executable their files can all be loaded together, so jumping to definition from app/Main.hs can land you in lib/Foo.hs.

However, so far each new component has been loaded into the session lazily, i.e. only when files belonging to the component are opened. There are caches involved, but each time this happens the GHC session is re-initialized from scratch: the new set of components, and how to build them, is discovered by querying the underlying build system, e.g. by invoking cabal repl/stack repl and extracting the flags they would pass to ghci. Ultimately the new component might have to go from being pre-compiled on disk to interpreted in-memory, forcing all its descendants to be reconfigured too, so even if we wanted to be more clever not much work could be saved.

This is not a big deal with just two components, but in a larger project it can be surprising to have HLS behave differently in a given file according to which other files have been opened. Also, when the session needs to be re-initialized because of a new component, the induced pause can be a bit jarring.

Whole project loading

The new whole project mode instead loads all project components right away, so that everything is available from the start. The downside is doing everything up front means memory use and initialization time are also paid up front. Also, a misconfigured component can stop the others from loading.

In Haskell Language Server

Eventually we hope to make whole project loading the default. For the moment, starting with haskell-language-server-2.15, the new feature is enabled by setting the new config field componentsLoading to multi: whole-project. The other options are multi: needed-only, which is the default, and single, which loads only a single component at once. The componentsLoading field replaces the previous sessionLoading one which is now deprecated: sessionLoading: "multipleComponents" is now componentsLoading: "multi: needed-only" and interpreted as such.

In Haskell Debugger

Haskell Debugger was actually the primary motivation for this work, as finding out in the middle of a debug session that you cannot add a breakpoint in an imported module is more dire than the issues with HLS.

Prior to whole-project loading, the typical setup where a package contains both a library and an executable that depends on it would end up with only the modules from the executable interpreted and so available to be stopped at. The library was installed in a temporary package database and included only as a dependency, so trying to set a breakpoint in a module from the library would just fail.

Haskell Debugger builds its session only once, as soon as it learns what the entry point is, i.e. the module and function to start execution from. At this point the debugger doesn’t know where the breakpoints will be, and so which modules need to be interpreted. As new breakpoints can be set while execution already started, waiting to know all of them to initialize the session is not an option.

Because of the above we have gone ahead and made whole-project loading the default and only way Haskell Debugger behaves, starting from the next release.

How it works and further configuration

What “all project components” means depends on the underlying cradle, either specified in a hie.yaml file or inferred from what can be found in the root directory. Recent enough Cabal and Stack are the two kinds of cradles that actually support this: if the hie.yaml file specifies components we load those, otherwise we ask the package manager to infer them. Inferring means asking Cabal for target all while enabling tests and benchmarks, or asking Stack for its default targets.

The above logic, like most of this new feature, is implemented by hie-bios starting from version 0.20. All details on how to fine-tune your cradle can be found in hie-bios’s README, including the new componentsToLoad field.

Before explaining the new field let’s go through a few examples with Cabal cradles to make things more concrete. For each case we will list the cabal repl invocation that hie-bios uses to fetch the correct flags.

A very minimal cradle (hie.yaml) will let cabal infer the components by using the target all, i.e.

cradle:
  cabal:

will result in cabal repl --enable-multi-repl --enable-tests --enable-benchmarks all. The --enable-* flags are included so that the session will cover everything in the project.

The --enable-* flags will override what specified in a cabal.project file, so if the cradle includes one we omit them, i.e.

cradle:
  cabal:
    cabalProject: "./cabal.project"

will result in cabal repl --enable-multi-repl --project-file=./cabal.project all.

If components are specified then those are the targets used, e.g.

cradle:
  cabal:
    components:
      - {"path": "./src", "component": "lib:foo"}
      - {"path": "./app", "component": "exe:foo"}

will result in cabal repl --enable-multi-repl lib:foo exe:foo.

Finally, if some component doesn’t play nice with cabal repl or the tooling that uses hie-bios, the field componentsToLoad can be used to specify the exact list of targets to use, for example

cradle:
  cabal:
    componentsToLoad: ["lib:foo","lib:bar"]

will result in cabal repl --enable-multi-repl lib:foo lib:bar.

Conclusion

Hopefully whole-project loading will provide a less surprising and smoother dev experience on projects with multiple components. It’s been my new default and working well for me since it got merged. Feedback is welcome on the HLS issue tracker. Issue #5005 is the issue about the feature introduction.

This work has been performed in collaboration with Mercury, who have a long-term commitment to the scalability and robustness of the Haskell ecosystem. Well-Typed are always interested in projects and looking for funding to improve HLS and other Haskell tools. Please contact info@well-typed.com if we might be able to work with you!

Gabriella Gonzalez: Dependent if expressions without dependent types

Wed, 02 Sep 2026 00:00:00 +0000

Folklore trick for dollar-store dependent types

Haskell Interlude: 85: Brent Yorgey

Wed, 26 Aug 2026 17:00:00 +0000

In today’s episode, we’re joined by Brent Yorgey, Associate Professor of Computer Science at Hendrix College and the creator, among other things, of the Diagrams vector graphics library and Swarm, a 2D programming and resource gathering game. We talk about teaching, domain specific languages, and competitive coding.

Episode links and transcript

Philip Wadler: The Gargantuan Lie That is Collapsing the World's Climate

noreply@blogger.com (Philip Wadler) — Tue, 25 Aug 2026 18:29:33 +0000

Adam McKay, director of Don't Look Up, points out what should be obvious but is easy to ignore.

Like all grand lies, “we have more time” takes many different forms, often focus-grouped. There are the lofty-sounding promises to reach “Net-zero emissions by 2050,” as if 24 years from now was soon enough. There are the queries of “What’s your carbon footprint?,” as if individual people with plastic bags or straws were the problem and not gigantic multinational corporations. There’s the accusation that anyone who expresses urgency is a “doomer.” There are those who treat climate as an abstraction to win political campaigns, first arguing that the Biden administration’s Inflation Reduction Act was a victory despite doing nowhere near enough to address the scale of climate collapse, and more recently that Democrats should just stop talking about climate and focus on more “winnable” issues. Most damaging and common of all, there are those who simply don’t mention it.
All of these distortions have robbed us of the most critical element people need to understand a threat and adjust their actions accordingly: context.
And make no mistake, when it comes to how much time we have, the data and the geological record are crystal clear.
For some badly-needed context, the last three years, likely for the first time in over 100,000 years, have averaged above the Paris Accords’ “do not cross” 1.5 degrees celsius planetary warming. Only ten years ago, that was considered catastrophic, but now mainstream news tells us it’s just a number.
...
Let’s do the context thing again: 2C will mean we have completely left the stable climate period known as the Holocene. This is the 11,000-year-old era that has given us large-scale crop and livestock agriculture, which gave us cities, written language, modern science and medicine, and warm beds and showers.
Before that, for hundreds of thousands of years in the Pleistocene era, humans (and our hominid ancestors) spent most of their time running from drought, fires, floods, extreme cold and heat, predators, and each other.
The population was likely no more than a few million people spread across the whole planet. At one point we may have almost gone extinct, with just 10,000 Homo sapiens clinging to life. But after the advent of the Holocene and its remarkably stable climate, in only 100 centuries the world population has risen to 8 billion.
That is what we stand to lose. In fact, if our institutions, news and elected officials continue to feed and water the oil company-conceived mega-falsehood that climate breakdown is something just “our great-grandkids need to worry about,” human civilization as we know it will collapse and billions could die. And we’re not talking about the far distant future. We are talking about collapse within years, not centuries. For real.

Philip Wadler: There is No AI

noreply@blogger.com (Philip Wadler) — Tue, 25 Aug 2026 17:57:53 +0000

I've searched with little success for ideas about how we can handle AI so that it benefits rather than harms society. Here is a suggestion from Jaron Lanier. It was published by the New Yorker in 2023, when GPT-4 was the latest model. Time named Lanier to its list of 100 most influential people in 2015.

A program like OpenAI’s GPT-4, which can write sentences to order, is something like a version of Wikipedia that includes much more data, mashed together using statistics. Programs that create images to order are something like a version of online image search, but with a system for combining the pictures. In both cases, it’s people who have written the text and furnished the images. The new programs mash up work done by human minds. What’s innovative is that the mashup process has become guided and constrained, so that the results are usable and often striking. This is a significant achievement and worth celebrating—but it can be thought of as illuminating previously hidden concordances between human creations, rather than as the invention of a new mind.
As far as I can tell, my view flatters the technology. After all, what is civilization but social collaboration? Seeing A.I. as a way of working together, rather than as a technology for creating independent, intelligent beings, may make it less mysterious—less like hal 9000 or Commander Data. But that’s good, because mystery only makes mismanagement more likely.
...
This concept, which I’ve contributed to developing, is usually called “data dignity.” It appeared, long before the rise of big-model “A.I.,” as an alternative to the familiar arrangement in which people give their data for free in exchange for free services, such as internet searches or social networking. Data dignity is sometimes known as “data as labor” or “plurality research.” The familiar arrangement has turned out to have a dark side: because of “network effects,” a few platforms take over, eliminating smaller players, like local newspapers. Worse, since the immediate online experience is supposed to be free, the only remaining business is the hawking of influence. Users experience what seems to be a communitarian paradise, but they are targeted by stealthy and addictive algorithms that make people vain, irritable, and paranoid.
In a world with data dignity, digital stuff would typically be connected with the humans who want to be known for having made it. In some versions of the idea, people could get paid for what they create, even when it is filtered and recombined through big models, and tech hubs would earn fees for facilitating things that people want to do. Some people are horrified by the idea of capitalism online, but this would be a more honest capitalism. The familiar “free” arrangement has been a disaster.
...
Consider what might happen if A.I.-driven tree-trimming robots are introduced. Human tree trimmers might find themselves devalued or even out of work. But the robots could eventually allow for a new type of indirect landscaping artistry. Some former workers, or others, might create inventive approaches—holographic topiary, say, that looks different from different angles—that find their way into the tree-trimming models. With data dignity, the models might create new sources of income, distributed through collective organizations. Tree trimming would become more multifunctional and interesting over time; there would be a community motivated to remain valuable. Each new successful introduction of an A.I. or robotic application could involve the inauguration of a new kind of creative work. In ways large and small, this could help ease the transition to an economy into which models are integrated.
...
There are also non-altruistic reasons for A.I. companies to embrace data dignity. The models are only as good as their inputs. It’s only through a system like data dignity that we can expand the models into new frontiers. Right now, it’s much easier to get an L.L.M. to write an essay than it is to ask the program to generate an interactive virtual-reality world, because there are very few virtual worlds in existence. Why not solve that problem by giving people who add more virtual worlds a chance for prestige and income?

Sandy Maguire: review2

Mon, 24 Aug 2026 23:26:00 +0000

Last time, we took a stroll down memory lane to review some ancient code I wrote, and see what/how I’d do things differently now. That was fun, and I have a new banger for us today.

Today’s example comes from the same place — a little vim-like text editor I was working on. Vim has this “repeat” operator which just does the same thing you did last time. It’s nice. Delete a word. Running repeat deletes another word. Kinda dinky in this example, but it can also rerun “increment every number in the next four paragraphs.”

Anyway, so that’s the feature I was trying to duplicate. But the action I was running might have done some IO, and I didn’t want to repeat the IO (because maybe the IO was to gather some input from the user, and repeating shouldn’t ask again.)

I was still high on my own supply of writing monads, so I approached this problem with a custom monad. The gist of the API was:

-- | A monad transformer adding the ability to record the results of IO actions
-- and later replay them.
data Again m a
instance Monad m => Monad (Again m)
instance MonadIO m => MonadIO (Again m)
instance MonadTrans Again

-- | Runs an action and records all of its sampled IO. Returns a action which
-- when invoked will use the recorded IO.
runAgain
    :: Monad m
    => Again m a
    -> m (m a)

-- | Marks an IO action to be memoized after its first invocation.
again
    :: ( MonadIO m
       , Typeable r
       )
    => IO r
    -> Again m r

I’m actually pretty impressed with past-me on this one. That’s a clean API, and the implementation was pretty cute.

newtype Again m a = Again
  { runAgain' :: RWST () [Dynamic] [Dynamic] m a
  }

once
    :: forall m r
     . ( MonadIO m
       , Typeable r
)
    => IO r
    -> Again m r
once action = do
    a <- dequeue >>= \case
        Just x  -> return . fromJust $ fromDynamic x
        Nothing -> liftIO action
    tell [toDyn a]
    return a
  where
    dequeue :: MonadState [r] m => m (Maybe r)
    dequeue = do
        get >>= \case
            []     -> return Nothing
            (x:xs) -> do
                put xs
                return $ Just x

The trick here is to keep MonadState [Dynamic] and a MonadWriter [Dynamic] instances around. This code uses the MonadState to pop off IO actions it’s already run, and the MonadWriter to keep track of new IO actions it needs to cache. The “magic” happens in runAgain, which runs it through once with an empty state, and then returns a new action with the MonadWriter results moved into the state for the next time around:

runAgain
    :: Monad m
    => Again m a
    -> m (m a)
runAgain action = do
    (a, w) <- evalRWST (runAgain' action) () []
    return $ do
        evalRWST (runAgain' action) () w
        return a

Simple. Clean. Elegant. Too bad it doesn’t actually work.

The following program crashes with an error coming from the unsafe use of fromJust in once:

oops :: Again (StateT Bool IO) ()
oops =
  -- Branch on the StateT
  lift get >>= \case
    -- The first time around...
    False -> do
      -- Cache a unit value
      once $ print ()
      -- Change the state value
      lift $ put True

    -- Since the state changed at the end of the first branch, we will take this
    -- branch the second time around...
    True -> do
      -- Calling 'once' the second time around gets its value from the cache,
      -- which has type @()@. But at this callsite, it ought to have type
      -- @Bool -> Bool@. Uh oh!
      f <- once $ pure not
      lift $ print ("uh oh!", f True)


ohNo :: IO ((), Bool)
ohNo = flip runStateT False $ do
  m <- runAgain oops
  m

The attack here comes from the fact that we can force the Again program down a different code path its second time around. And that second time, it encounters a call to once which has a different type than the one it cached. Thus, trying to reuse the cache leads to what is effectively a type error at runtime.

What actually went wrong here? The problem is that monads are too powerful. Since the only way to compose monads is via bind (m a -> (a -> m b) -> m b), we are forced to extend a monadic value of type m a by a function of type a -> m b. Which is to say that the “next thing to do” in a monadic computation is always going to be a function. And functions are completely opaque. So, once we’re given a monad, there’s simply no way to know what it’s going to do without actually running the continuation.

The problem arises from the fact that that continuation can invisibly branch. My Again monad was attempting to statically analyze the monadic computation, and cache the IO results in a queue. But as oops shows, it’s trivial to break this sort of static analysis. Because the branch is hidden inside of a function, and there’s no way to determine which branches a function didn’t take.

But I didn’t know that eleven years ago, so I give myself a pass on this one. Nevertheless, let’s tackle this problem with the wisdom of ages.

No More Monads

So if the problem with my previous implementation of Again is that it’s a monad, what options do we have? As it happens, there are two very nice options available to us here: arrows and selective applicative functors. We’ll discuss arrows for now, and come back to selectives.

Long time readers might remember a series on arrows from a few years back. But if you don’t, that’s OK; you’re still welcome here. A quick recap:

Arrows are a generalization of functions. Like functions, they take two type parameters (an input and an output). Like functions, they come with an identity arrow. They compose “end to end” just like functions do. These three properties are expressed as a Category superclass, which we usually call c and write infix:

class Category (c :: Type -> Type -> Type) where
  id  :: x `c` x
  (.) :: (y `c` z) -> (x `c` y) -> (x `c` z)

In addition to being categories, arrows also come with a means of transforming regular functions into arrows, and of mapping arrows over pairs:

class Category c => Arrow c where
  arr :: (x -> y) -> (x `c` y)
  (***) :: (x `c` x') -> (y `c` y') -> ((x, y) `c` (x', y'))

What’s neat about arrows is that their values are function-like things, rather than being actually functions. That means when we compose arrows, we compose values whose internals we get to choose. Which in turn, means that static analysis is possible again!

Attentive readers will notice that there isn’t actually any way for arrows-as-such to be able to branch. To gain that capability, they require an additional ArrowChoice, which equips them with the ability to lift arrows over Either:

class Arrow c => ArrowChoice c where
  (+++) :: (x `c` x') -> (y `c` y') -> (Either x y `c` Either x' y')

To wet our whistle, let’s write a little helper Arrow that shows that the composition of an applicative functor with an arrow is itself an arrow:

newtype Static m c x y = Static
  { unStatic :: m (c x y)
  }

The arrow instances for (Applicative m, Arrow c) => Static m c are the usual trick of using applicative functions to lift operations into the right place. For example, identity is just pure id, and composition isliftA2` of composition:

instance (Category c, Applicative m) => Category (Static m c) where
  id = Static $ pure id
  Static g . Static f = Static $ liftA2 (.) g f

We can do the same trick for arr and (***):

instance (Arrow c, Applicative m) => Arrow (Static m c) where
  arr = Static . pure . arr
  Static f *** Static g = Static $ liftA2 (***) f g

as well as for (+++):

instance (ArrowChoice c, Applicative m) => ArrowChoice (Static m c) where
  Static f +++ Static g = Static $ liftA2 (+++) f g

What’s nice about this Static construct we’ve built is that it gives us two degrees of freedom. We’re free to choose an arrow whose structure we’re going to reuse, and an underlying applicative functor (which can give us “static” effects as we’re building the underlying arrow.)

The idea here is that we can put the cache-building machinery inside of the applicative functor, but the cache-reading machinery inside of the underlying arrow.

Constructing Again, Again

It’s worth knowing about the Kleisli arrow:

newtype Kleisli m a b = Kleisli
  { runKleisli :: a -> m b
  }

instance Monad m => Category (Kleisli m)
instance Monad m => Arrow (Kleisli m)
instance Monad m => ArrowChoice (Kleisli m)

which says that any monadic bind function is itself an arrow. Implementing the instances yourself is a fun exercise if you’re new to this stuff. We can reuse Kleisli as our underlying arrow, which when you expand everything out, we get:

newtype Again m a b = Again
  { unAgain :: Static m (Kleisli m) a b
  }
  deriving newtype (Category, Arrow, ArrowChoice)

runAgain :: Monad m => Again m a b -> m (a -> m b)
runAgain = fmap runKleisli . unStatic . unAgain

What I think is particularly cool about this is that runAgain is just the composition of the newtype unwrappers, and yet its type is extremely reminiscent of my ten-year-ago implementation:

runAgain  -- the original
    :: Monad m
    => Again m a
    -> m (m a)

This is an instance of a more general principle, which is that the final “observation” you want to make of your type is always a good representation of that type. It’s not the only representation, but it’s always a reasonable choice. Appropriately enough, this is known as a final encoding.

Anyway. How can we implement once? By way of onceF:

onceF :: (MonadIO m, Ord a) => (a -> IO b) -> Again m a b
onceF m = Again $ Static $ do
  cache <- liftIO $ newIORef mempty
  pure $ Kleisli $ \a -> liftIO $ do
    cacheMap <- readIORef cache
    case M.lookup a cacheMap of
      Just b -> pure b
      Nothing -> do
        b <- m a
        modifyIORef' cache $ M.insert a b
        pure b

once :: MonadIO m => IO b -> Again m a b
once m = arr (const ()) >>> onceF (const m)

onceF works by constructing a cache :: IORef (Map a b) at the Static level. Each call to onceF gets a unique cache. Then we drop into the implementation of the Kleisli arrow (which recall happens at runtime.) Inside the Kleisli, we check to see if the map has a value at the requested a, and if so, return the cached b. If not, we run our function and cache it.

Since there’s no Dynamic tomfoolery here that is existentializing away our types, we don’t need to worry about the oops attack; Haskell’s type system guarantees we can’t construct such a thing.

Because Again isn’t a Monad, it can’t be a MonadIO either. But it’s nice to be able to provide the equivalent of liftIO:

againF :: MonadIO m => (a -> IO b) -> Again m a b
againF = Again . Static . pure . Kleisli . fmap liftIO

again :: MonadIO m => IO a -> Again m x a
again m = arr (const ()) >>> againF (const m)

So that completes our arrow-based implementation of Again. But there’s still something left undone.

Circling Back to Selectives

I said earlier that selective applicative functors would be an alternative approach to implementing Again. Selectives rightfully sit between Applicative and Monad in the functor hierarchy, but were discovered too late, and everyone was still kind of annoyed about having had just stuck Applicative into the hierarchy.

What, precisely is a selective functor? It’s a different solution to the problem of “monads are too powerful” which gives us a branching primitive to play with. Behold:

class Applicative f => Selective f where
  select :: f (Either a b) -> f (a -> b) -> f b

select says that you might have an a, in which case you must run the provided f (a -> b). But maybe you have a b, in which case you may run the effects of the f (a -> b). But nobody’s forcing you to.

Since there are still no raw function continuations to be seen here, we can use select to provide branching to our programs. But all of the branches can be identified statically, since we’re only operating on f values, again, whose internals we can control.

In fact, by aggressively nesting select calls, you can get back a version of monadic bind — so long as you have a finite number of select calls you’d need to make:

bindS
    :: (Selective f, Enum a, Bounded a, Eq a)
    => f a
    -> (a -> f b)
    -> f b

(the implementation of which is fun if you’re looking for a challenge)

Anyway, all of this is to say that we could have equally structured our Again as a selective functor rather than as an arrow! But ArrowChoice is at least as powerful as Selective, so given all of our hard work already, we can pull out a Selective instance for free.

What do I mean when I say “at least as powerful?” It means we can derive it for free, given an ArrowChoice instance. Behold, the GenericArrow newtype, which exists only for us to have something to attach some instances to.

newtype GenericArrow c x a = GenericArrow
  { unGenericArrow :: c x a
  }
  deriving newtype (Category, Arrow, ArrowChoice)

Here we use newtype deriving to say that if c is a category/arrow/arrowchoice, then GenericArrow c is too. But now we can show that having Arrow is enough to get Functor and Applicative instance:

instance Arrow c => Functor (GenericArrow c x) where
  fmap f c = arr f . c

instance Arrow c => Applicative (GenericArrow c x) where
  pure = arr . const
  liftA2 f x y = (x &&& y) >>> arr (uncurry f)

Then, given an ArrowChoice, we can get an implementation of select:

instance ArrowChoice c => Selective (GenericArrow c x) where
  select te tk = proc b -> do
    e <- te -< b
    case e of
      Left x -> do
        k <- tk -< b
        returnA -< k x
      Right y -> returnA -< y

Here we don’t have the option of choosing to invoke tk in the Right case. But that’s OK, because in Again, doing so would correspond to creating caches for branches that don’t need it.

Given all of this, we can now derive Functor up to Selective for Again:

newtype Again m a b = Again
  { unAgain :: Static m (Kleisli m) a b
  }
  deriving newtype (Category, Arrow, ArrowChoice)
  deriving (Functor, Applicative, Selective) via GenericArrow (Again m) a

which means that users can now choose between the arrow hierarchy and the functor hierarchy for how they’d like to think about building Again actions. And to nudge them even a little further, we can introduce something that looks like a monad transformer, removing the input parameter:

type AgainT m = Again m ()

runAgainT :: Monad m => AgainT m a -> m (m a)
runAgainT = fmap ($ ()) . runAgain

Clean. Tidy. Actually works this time around.

Chris Smith 2: How to (Almost) Trisect an Angle

Sun, 23 Aug 2026 14:46:19 +0000

In 1837 Pierre Wantzel proved that no compass-and-straightedge construction can trisect every angle. The counterexample is 60°: trisecting it would mean constructing cos 20°, which is a root of an irreducible cubic, while a compass and straightedge can only build stacks of square roots: objects of degree 2, 4, 8, never 3. And since 60° is easy to construct, any general method for trisection would have to trisect that one, too.

None of this has stopped people trying. For well over a century, mathematics departments have received a steady stream of constructions from amateurs convinced they’d done the impossible, enough of them that Underwood Dudley filled a whole book, The Trisectors, with them.

I used to be one of those amateurs. Well, I was twelve, and my construction never made it into any mathematician’s inbox. But I had the essentials: a method, a compass and straightedge, a very exasperated geometry teacher, and a conviction that the experts had given up too soon.

What you can trisect

So you can’t trisect an angle, but there are things you can trisect. Say the angle is AVB, with vertex V and measure θ, and mark A and B the same distance out from V. Draw the arc centered at V from A to B. Cutting that arc into three equal pieces is the same as cutting the angle into three, so the whole problem comes down to trisecting that one arc, and that arc is the one Wantzel showed is off limits. But it belongs to a whole family of arcs from A to B, some fatter, some flatter, and other members of the family can be trisected exactly.

Pick one, trisect it, and read the result back as an approximate trisection of the angle. How wrong you are depends on how far apart the two arcs sit.

Idea #1: Trisect the chord instead

Start with the flattest member of the family. Push the arc’s center infinitely far back and the arc straightens into the segment AB itself. Segments can be trisected exactly, by a standard similar-triangles construction, or more slickly through the centroid of a triangle. Either way, trisect AB, draw rays through the two division points, and you have approximate trisectors. Call this chord trisection.

For narrow angles, chord trisection works remarkably well. As the angle shrinks the arc flattens toward its chord, and the error vanishes like θ³/81 (in radians, plus higher-order terms). That cubic is fast: a 4° angle gets trisected to within a few ten-thousandths of a degree. Wide angles are another story. The arc bulges away from the chord, the chord’s trisection points crowd toward the sides of the angle, and as θ approaches 180° the middle third of the trisection swallows the whole angle.

So chord trisection is wonderful for narrow angles and hopeless for wide ones.

Idea #2: Trisect a semicircle instead

This is the method I found that year in geometry class. Slide the arc’s center the other way, up from V as far as it will go, to the midpoint of AB. The arc swells into the semicircle on AB, pointing away from V. A semicircle is easy to trisect, because its thirds are 60° arcs, and you mark those off by stepping the radius along the arc with your compass. Rays from V through the two marks are your approximate trisectors. Call this semicircle trisection.

You’d expect semicircle trisection to do well at wide angles, and it does. At θ = 180° the semicircle stops being a stand-in altogether: V lands at the midpoint of AB, the semicircle coincides with the angle’s own arc, and the trisection is exact. Narrow the angle from there and the true arc pulls away from the semicircle, so the error grows…

Then it does something surprising: it turns around, comes back to exactly zero at θ = 90°, then rises and falls once more on the way down to zero at θ = 0, never getting more than 1.226° from the true trisector anywhere along the way. The worst cases sit at arcsin(1/√3) ≈ 35° and its supplement near 145°.

The zero at 0° is just collapse. A and B merge, the whole angle closes onto a single ray, and the constructed trisectors converge onto it along with everything else. The zero at 90° is the interesting one, and it turns out to be the inscribed angle theorem. A right angle inscribed in a circle subtends a diameter, so a 90° vertex V lies on the very circle the trisection marks were drawn on, and each 60° arc of that circle subtends exactly 30° at V.

You can see how I fell for this. The three cases I knew how to check — 0°, 90°, 180° — were all exact, and an error under 1.226° passes the eyeball test everywhere else. The weakness hides at small angles, which are the hardest to check on paper. As θ approaches 0, semicircle trisection hands back a ray a quarter of the way across the angle instead of a third. Less than a degree off, sure, but when the whole angle is a few degrees, that’s a low bar. The error remains a substantial fraction of the answer no matter how small θ gets.

We have two approximations, then, with opposite strengths. Chord trisection converges cubically for small angles but blows up for large ones. Semicircle trisection stays within about a degree everywhere but converges to the wrong ray as the angle shrinks. It would be nice to get the best of both worlds, wouldn’t it?

Bridge: The exact residual trick

Draw the arc centered at V through A and B, and suppose someone hands you a guess: a point G on the arc, with VG claimed to be a trisector. Set your compass to the chord distance from A to G. Starting at B, step backwards that distance twice along the arc toward A, and call the landing point H.

Claim: the trisector of the (probably small) angle GVH adjacent to VG is exactly the trisector of AVB adjacent to VA.

Proof: Write the guess as arc(A→G) = θ/3 + ε, where ε is its unknown error. Each compass step from B moves an arc of θ/3 + ε, so after two steps H sits at θ − 2(θ/3 + ε) = θ/3 − 2ε from A. The residual arc from H to G is therefore exactly 3ε, and a third of the way from G toward H lands at θ/3 + ε − ε = θ/3, for either sign of ε.

The residual angle GVH is exactly three times the guess’s error, and nothing in the reduction is approximate. Trisecting AVB has been converted, exactly, into trisecting a much smaller angle.

Putting the pieces together

So here’s the plan. Feed any angle at all, 5° or 175°, to semicircle trisection, and it hands back a guess within 1.226° of the true trisector. The residual trick then turns that guarantee into a fresh problem: an angle of at most 3.68° whose trisector is exactly the ray we’re after. And 3.68° is chord territory, small enough for the cubic convergence to bite, handing us a remarkable 0.674 arcseconds of error: roughly the angle spanned by a penny viewed from three and a half miles away.

Nothing stops you from running the residual trick again on the improved answer; each round cubes the error. But one pass already lands within an arcsecond, and iterating would be polishing a quantity that stopped mattering a step ago.

Mark Jason Dominus: The road to epsilon-zero: Shortlex order also orders sequences of numbers

mjd@plover.com (Mark Dominus) — Sat, 22 Aug 2026 00:26:00 +0000

Previously:

In part 4, Infinite Nim as a coin-moving game, we saw how to reinterpret infinite Nim into an equivalent game: instead of heaps of beans and various special tokens, we interpreted it as a game about moving coins first on a track, then on a grid, and then in a rather difficult-to-visualize infinite-dimensional space.

In part 5, Coin-moving games with no coins, we stopped thinking about the coins and their locations in space, and just wrote down the coordinates of each coin. Each coin has an infinite sequence of coordinates, each of which is a non-negative number. But crucially, only a finite number of the coordinates are greater than zero, so every coin's list of coordinates can be written down as a finite sequence, with the infinite tail of zeroes left implicit.

The rule for the original game of Nim was: take as many beans as you want from any one pile.

The rule for the reinterpreted form is: reduce any one sequence of coordinates, as follows:

Pick any nonzero coordinate
Reduce it by at least 1
Replace any coordinates to the left of that one with any numbers at all

For example, we can move from to (the has decreased), or to (the has decreased). We can move from to (the has decreased), or to , which we can also write as .

Now that we've learned about shortlex order, we can state the game rule more simply:

Replace any one sequence of coordinates with one that is earlier in shortlex order.

There's one minor wrinkle. We had defined shortlex order as:

If the sequences are different lengths, the shorter one comes first.
If they're the same length, compare them lexicographically.

None of that has changed, but we need to be a bit careful about “lexicographically”.

When we write ordinary numerals, like 239, we write the most significant part on the left. In this case it's the , which represents . And when we compare numerals of the same length lexicographically, we compare these most significant parts first, moving rightward only if the leftmost parts are tied.

To lexicographically compare sequences of coordinates or the same length, we still need to begin with the most significant part as before. But because of how we are writing the sequences, the most significant part is the rightmost component. A sequence like represents a nim-heap of beans, and the is the most significant component, because is vastly more than beans.

I said at some point that was where the ordinals start to get scary. But is now not scary at all. It's just the family of of nim-heaps where:

Instead of beans, we think of a heap as a finite sequence of finite numbers
Instead of imagining the player removing beans from a heap, we imagine them replacing the sequence with a sequence that is earlier in shortlex order

And to play Nim with ⸢heaps⸣ of this sort, the winning rule is, as always, that the winner is the player who reduces the last ⸢heap⸣ to to zero.

We can completely forget about beans, about infinite piles, about infinite varieties of colored tokens, about coins moving around in infinite-dimensional spaces, and so on. -Nim is just finite sequences of ordinary numbers, and you can move from one sequence to any earlier one.

I think is going to arrive in the next article.

Claude was on vacation this week, and took all the em-dashes with it, so I not only had to write the whole thing myself, I couldn't even put in any em-dashes.

Sandy Maguire: Code-Reviewing My First Monad Implementation

Fri, 21 Aug 2026 23:50:00 +0000

I’ve been wanting to get back into the habit of blogging, and thought a fun project would be to go back through my old code and review it as the programmer I am now. So let’s do that.

Eleven years ago, I was so proud to written my first monad that I typed up a big olblog post about it. This seems like a fun thing to revisit, so let’s do it.

To save you the trouble of reading that ancient-ass blog post, here’s the gist. Given a big piece of state, that has many smaller stateful subcomponents, for example, a World is full of Buffers:

data World = World
  { wBuffers :: [Buffer]
  , wCurrent :: Int
  , wMode    :: Mode
  }

data Buffer = Buffer
  { bFilename :: FilePath
  , bContent  :: String
  }

my monad acted like StateT except that you can restrict the piece of the state you’re allowed to manipulate without losing the ability to look at the rest of the state.

In the blog post, this monad is called Jurisdiction, but at some point in the source code it got renamed to JailT. Cool name. Furthermore, the implementation changed rather dramatically from the blog post, so let’s chase the implementation as given. I’ll reproduce it here:

type RLens r s = Lens s s r r

newtype JailT s r m a =
    JailT
    { runJailT' :: Bool
                -> RLens r s
                -> s
                -> m (a, s, RLens r s, Bool) }
    deriving (Functor, Typeable)

instance (Applicative m, Monad m) => Applicative (JailT s r m) where
    pure x = JailT $ \v l s -> pure (x, s, l, v)
    (<*>)  = ap

instance (Applicative m, Monad m) => Monad (JailT s r m) where
    return   = pure
    ac >>= k = JailT $ \v l s ->
        if v
            then do
                (x, st', l', v') <- runJailT' ac v l s
                runJailT' (k x) v' l' st'
            else return (undefined, s, l, v)

Already there’s a lot to look at. The most immediate thing that strikes me is the formatting; now I’m very much a “use two spaces for indent” kind of guy — Haskell doesn’t provide many opportunities for natural linebreaks, and our horizontal space is much more limited than our vertical space. So don’t throw away your horizontal budget on initial spacing. It’s minor, but being an artisan means caring about the minor details.

newtype JailT s r m a = JailT
  { runJailT'
      :: Bool
      -> RLens r s
      -> s
      -> m (a, s, RLens r s, Bool)
  }
  deriving (Functor, Typeable)

Much nicer.

The other exciting thing to see in the earlier snippet is that this code comes from before the Functor-Applicative-Monad transition. Which is to say that it’s from the long long ago before Applicative was a superclass on Monad. There’s some history for you.

And then there is the elephant in the room. Whatever this Bool is being passed around by runJailT', the Monad instance branches on it and returns undefined when it’s False. What the hell is that???? Digging into the MonadPlus instance provides some insight:

instance (Applicative m, Monad m) => MonadPlus (JailT s r m) where
    mplus x y = JailT $ \v l s -> do
        x'@(xa, xs, xl, v') <- runJailT' x v l s
        if v'
           then return x'
           else runJailT' y v l s
    mzero = JailT $ \v l s -> return (undefined, s, l, False)

So mzero returns undefined and some False value, presumably which is there to try to warn someone that there’s an undefined floating around.

This is a stupid design. If you’re ever in the business of needing to store data-which-might-not-be-valid and a separate tag stating whether or not it’s valid, a much better design here would be to just use Maybe a instead of (a, Bool).

In fact, perhaps I realized this later on, because runJailT does exactly this logic:

runJailT :: (Functor m)
         => JailT s s m a
         -> s
         -> m (Maybe (a, s))
runJailT ac = fmap (\(a, s, _, v) ->
                            if v then Just (a, s) else Nothing)
                    . runJailT' ac True id

Let’s roll back a bit. The pivotal primitive of JailT is the aptly-named jail:

jail :: (Monad m)
     => RLens r' r
     -> JailT s r' m a
     -> JailT s r m a
jail l' m = JailT $ \v l s -> do
    (a, s', _, v') <- runJailT' m v (l . l') s
    return (a, s', l, v')

Pretty reasonable definition here. I’m not sure what the idea behind RLens being a flipped version of Lens' was for. The only odd choice here is that in the big tuple returned in jail, l gets passed along unchanged. We can tell from looking at it that l here is the current lens we’re looking at. But jail is the only primitive that changes the lens, and it takes a JailT as an argument. Which is all to say that there isn’t anything actually stateful going on with the RLens. So without looking any further, I’d bet dollars to donuts that this l getting returned is purely vestigial and serves absolutely no purpose. Which in turn means we should be able to chop it out of the definition of JailT.

Speaking of stupid anti-patterns, here’s another one:

into :: RLens a (Maybe a)
into = lens fromJust (const Just)

jailMaybe :: (Applicative m, Monad m)
          => RLens (Maybe r') r
          -> a
          -> JailT s r' m a
          -> JailT s r m a
jailMaybe l d m =
    (gets $ view l) >>= \case
        Just _  -> jail (l . into) m
        Nothing -> return d

This is horrendous for a few reasons. into is an unsafe lens that will crash if you try to read out of a Nothing. But then that behavior is guarded in jailMaybe by checking that it isn’t already nothing. Stupid.

The last function I want to point out is parole:

parole :: (Applicative m, Monad m)
       => a
       -> JailT s r m (Maybe a)
       -> JailT s r m a
parole d m = do
    this <- get
    m >>= \case
        Just a  -> return a
        Nothing -> put this >> return d

which… does… something. I guess it attempts to run a Maybe-valued JailT, and if it fails, unwinds the state and returns some default a. Rearing its ugly head here, however, is the ghost of the undefined nonsense from mzero. Note that if we invoke parole a mzero we will get a crash rather than the roll-back-and-default behavior that it promises on the tin.

So, all in all, I am not particularly impressed with my first monad. Here’s how I’d write it today.

First, I don’t think I’ve written a “control”-y sort of monad from scratch in the last five years. Whatever behavior you want is almost always just the composition of a few monad transformers. In this case, we have a Reader for the current lens, a State for the original state, and a Maybe to give us mzero semantics.

Since we want our state to roll-back when we take an alternative path, we must put MaybeT underneath our StateT.¹ This gives us the nice formulation of a JailT as:

newtype JailT s r m a = JailT
  { unJailT :: ReaderT (ALens' s r) (StateT s (MaybeT m)) a
  }

(we use ALens' s r here instead of Lens' s r since the latter requires -XImpredicativeTypes. Which happens to be turned on in the original implementation!)

Once nice thing about defining our monad as a newtype over a series of monad transformers, is that it allows us to newtype-derive all of the relevant instances:

  deriving newtype (Functor, Applicative, Monad, MonadIO, Alternative)

No implementation for such things is required, and therefore we know that the derived instances must be correct. Which means we have many fewer things to worry about.

I prefer to use unWhatever as my naming scheme for these newtypes, so that I can provide runWhatever as a more user-friendly function.

runJailT :: s -> Lens' s t -> JailT s t m a -> m (Maybe (a, s))
runJailT s l = runMaybeT . flip runStateT s . flip runReaderT l . unJailT

What’s also nice about using standard monad transformers for your implementation is that you can reuse all of their existing combinators. For example, to implement jail all we need to do is invoke withReaderT :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a, which lets us change the type of the reader.

jail :: Lens' t u -> JailT s u m a -> JailT s t m a
jail ltu = JailT . withReaderT (\lst -> cloneLens lst . ltu) . unJailT

Notice here that I like to minimize my points without going point-free; jail as written is very legible, but writing it entirely pointfree is a crime against humanity:

-- don't do this!
jail = (JailT .) . (. unJailT) . withReaderT . flip ((.) . cloneLens)

Rather than implementing parole directly, we can note that it is the composition of two pieces — (1) attempt something, (2) return a default if it failed. Whenever you notice de-composition opportunities like this, take them!

We can write attempt, which is wildly general and doesn’t care one fig about jails or the legal system:

attempt :: (Alternative m, Monad m) => m (Maybe a) -> m a
attempt m = maybe empty pure =<< m

and then parole is merely

parole :: Monad m => a -> JailT s t m (Maybe a) -> JailT s t m a
parole a0 j =
  asum
    [ attempt j
    , pure a0
    ]

All in all, significantly nicer if you ask me. But I’m just a TV. Don’t take my word for it. Compare for yourself!

Original Implementation

{-# LANGUAGE GeneralizedNewtypeDeriving,
             FlexibleInstances, MultiParamTypeClasses,
             DeriveFunctor, ImpredicativeTypes, LambdaCase,
             DeriveDataTypeable #-}

import Control.Applicative (Alternative(..))
import Control.Monad (ap, MonadPlus(..))
import Control.Monad.State
import Control.Lens
import Data.Maybe (fromJust)
import Data.Typeable


type RLens r s = Lens s s r r

newtype JailT s r m a =
    JailT
    { runJailT' :: Bool
                -> RLens r s
                -> s
                -> m (a, s, RLens r s, Bool) }
    deriving (Functor, Typeable)

instance (Applicative m, Monad m) => Applicative (JailT s r m) where
    pure x = JailT $ \v l s -> pure (x, s, l, v)
    (<*>)  = ap

instance (Applicative m, Monad m) => Monad (JailT s r m) where
    return   = pure
    ac >>= k = JailT $ \v l s ->
        if v
            then do
                (x, st', l', v') <- runJailT' ac v l s
                runJailT' (k x) v' l' st'
            else return (undefined, s, l, v)

instance (Applicative m, Monad m) => MonadState r (JailT s r m) where
    get   = JailT $ \v l s -> return (view l s, s, l, v)
    put x = JailT $ \v l s -> return ((), set l x s, l, v)

instance MonadTrans (JailT s r) where
    lift x = JailT $ \v l s -> x >>= (\a -> return (a, s, l, v))

instance (Applicative m, MonadIO m) => MonadIO (JailT s r m) where
    liftIO = lift . liftIO

instance (Applicative m, Monad m) => MonadPlus (JailT s r m) where
    mplus x y = JailT $ \v l s -> do
        x'@(xa, xs, xl, v') <- runJailT' x v l s
        if v'
           then return x'
           else runJailT' y v l s
    mzero = JailT $ \v l s -> return (undefined, s, l, False)

instance (Applicative m, Monad m) => Alternative (JailT s r m) where
    (<|>) = mplus
    empty = mzero

runJailT :: (Functor m)
         => JailT s s m a
         -> s
         -> m (Maybe (a, s))
runJailT ac = fmap (\(a, s, _, v) ->
                            if v then Just (a, s) else Nothing)
                    . runJailT' ac True id

type Jail s r = JailT s r Identity
runJail :: Jail s s a
        -> s
        -> Maybe (a, s)
runJail ac = runIdentity . runJailT ac

jail :: (Monad m)
     => RLens r' r
     -> JailT s r' m a
     -> JailT s r m a
jail l' m = JailT $ \v l s -> do
    (a, s', _, v') <- runJailT' m v (l . l') s
    return (a, s', l, v')

into :: RLens a (Maybe a)
into = lens fromJust (const Just)

jailMaybe :: (Applicative m, Monad m)
          => RLens (Maybe r') r
          -> a
          -> JailT s r' m a
          -> JailT s r m a
jailMaybe l d m =
    (gets $ view l) >>= \case
        Just _  -> jail (l . into) m
        Nothing -> return d

escape :: (Applicative m, Monad m)
       => JailT s s m a
       -> JailT s r m a
escape m = JailT $ \v l s -> do
    (a, s', _, v') <- runJailT' m v id s
    return (a, s', l, v')

freedom :: (Applicative m, Monad m) => JailT s r m s
freedom = JailT $ \v l s -> return (s, s, l, v)

-- happens to be unused, because it's kinda insane??
overwrite :: (Applicative m, Monad m)
          => RLens r' r
          -> JailT r r' m a
          -> JailT s r m a
overwrite l' m = JailT $ \v l s -> do
    (a, s', _, v') <- runJailT' m v l' $ view l s
    return (a, set l s' s, l, v')

parole :: (Applicative m, Monad m)
       => a
       -> JailT s r m (Maybe a)
       -> JailT s r m a
parole d m = do
    this <- get
    m >>= \case
        Just a  -> return a
        Nothing -> put this >> return d

inspect :: (Applicative m, Monad m)
        => RLens i r
        -> JailT s r m i
inspect l = gets $ view l

inquire :: (Applicative m, Monad m)
        => RLens i s
        -> JailT s r m i
inquire l = view l <$> freedom

arrest :: (Applicative m, Monad m)
       => RLens r' r
       -> r'
       -> JailT s r m ()
arrest l v = do
    state <- get
    put $ set l v state

arrests :: (Applicative m, Monad m)
        => RLens r' r
        -> (r' -> r')
        -> JailT s r m ()
arrests l f = do
    state <- get
    put $ set l (f $ view l state) state

vs the

New Implementation

{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE RankNTypes                 #-}

import Control.Applicative
import Control.Lens
import Control.Monad.State
import Control.Monad.Reader
import Control.Monad.Trans.Maybe


newtype JailT s r m a = JailT
  { unJailT :: ReaderT (ALens' s r) (StateT s (MaybeT m)) a
  }
  deriving newtype (Functor, Applicative, Monad, MonadIO, Alternative)

instance Monad m => MonadState r (JailT s r m) where
  get = JailT $ do
    l <- asks cloneLens
    gets $ view l
  put r = JailT $ do
    l <- asks cloneLens
    modify $ set l r

runJailT :: s -> Lens' s t -> JailT s t m a -> m (Maybe (a, s))
runJailT s l = runMaybeT . flip runStateT s . flip runReaderT l . unJailT

jail :: Lens' t u -> JailT s u m a -> JailT s t m a
jail ltu = JailT . withReaderT (\lst -> cloneLens lst . ltu) . unJailT

escape :: JailT s s m a -> JailT s t m a
escape (JailT j) = JailT $ withReaderT (const id) j

freedom :: Monad m => JailT s t m s
freedom = JailT get

attempt :: (Alternative m, Monad m) => m (Maybe a) -> m a
attempt m = maybe empty pure =<< m

parole :: Monad m => a -> JailT s t m (Maybe a) -> JailT s t m a
parole a0 j =
  asum
    [ attempt j
    , pure a0
    ]

arrest :: Monad m => Lens' t u -> u -> JailT s t m ()
arrest l u = modify $ set l u

Maybe this was interesting to you. It certainly was fun for me, because I like tearing apart bad code, and I don’t get to see much of it now that I have very talented colleagues. Thankfully I have a huge amount of crap code from my past, including an even more egregious monad that we’ll tackle next time around.

Unwrap the definitions of StateT s Maybe a and MaybeT (State s) a to see why.↩︎

Mark Jason Dominus: The road to epsilon-zero: Productive programs and well-founded orders

mjd@plover.com (Mark Dominus) — Thu, 13 Aug 2026 23:30:00 +0000

Previously:

Previously we saw how to interpret the difficult-seeming ordinal as a particular ordering of the set of finite sequences of numbers, revealing what seemed like a scary monster as gentle and straightforward.

Now we're going to take a sidetrack into one of my favorite topics, computation with infinite lists. I wrote about this for The Perl Journal in 1997 and then it turned into chapter 6 of Higher-Order Perl and here we are again. Gosh! it just keeps coming back. Like John the Baptist.

Infinite lists

Suppose you have an infinite set of strings — we'll call this set for the rest of the article — and you want a program to print them all out. Of course the program can't exactly print them all out, because it will only run for a finite amount of time. But there are more and less useful ways for the program to try.

For each string that the program is supposed to print, we should at least be able to guarantee that the the program will print it, eventually, if we just wait long enough. If this is true then we'll say that the program is “productive”.

Here's a productive program to print the base-10 numerals for all the positive integers:

    # Python

    i = 1
    while True:
      print(i)
      i += 1

What would a non-productive program look like? Here's an example of a non-productive program to print the base-10 numerals for all the positive integers:

    # Python, silly

    i = 1
    while True:   # print all the odd numbers
      print(i)
      i += 2

    i = 2
    while True:   # then print all the even numbers
      print(i)
      i += 2

This one tries to print all the odd numbers first, and then all the even numbers. Obviously that doesn't work because it never finishes with the odd numbers. If you were to sit around waiting for the number , you'd wait forever. Whereas with the first program, whatever number you are waiting for, even if it is very very big, it will come out eventually.

That's what I meant when I said there are more and less useful ways for a program to try to print an infinite set. The first one never finishes, true, but the way in which it never finishes is much more useful than the way in which the second one never finishes.

Okay, that was a silly example. But there are less silly examples.

Printing strings in sorted order

A productive program is always semidecidable: if a user wants to know if some particular string is in , and they wait long enough, will come out and they have the answer. But if isn't in , they never find that out! They just wait and wait, wondering if it will come out, and never getting a definitive answer.

If we can get a productive program to produce its strings in sorted order, we can make a better guarantee. The program will be decidable: the user will eventually get an answer, one way or the other. If the productive program will eventually produce , and the user can stop watching. But if , the program must eventually produce a string that comes after in sorted order, and they can quit then. And the program must eventually produce some string that comes after , because, being productive, it eventually produces every string in .

(What if there is no string in that comes after in sorted order? Then the productive program will first produce all the strings that precede , then it will produce , and then it will halt. When it does that user has their answer, whatever it is.)

Not every program is productive

The non-productive program I showed above is silly, but productivity isn't something you can always guarantee, if you want the data in sorted order. Some orders work, and some don't.

The conventional order for strings, implemented by Python's < operator or C's strcmp, is called lexicographic, which means “dictionary-style”. There are some sets of strings for which no productive program can print all the strings in lexicographic order.

For example, consider the set of all strings that are made up of either all as or all bs:

    a
    b
    aa
    bb
    aaa
    bbb
    aaaa
    bbbb
    …

Notice that this list is not in lexicographic order, because in lexicographic order, the string aa should come out before b.

There is no productive program to print this set in lexicographic order. Why not? Because in lexicographic order the list begins like this:

    a
    aa
    aaa
    aaaa
    aaaaa
    …

and the program never gets around to printing any of the strings with bs. This is analogous to how the non-productive example earlier waited to print even numbers until after it was finished with the odd numbers. To print these strings in lexicographic order would meansto print the strings beginning with b after printing the strings beginning with a. But the program never does finish with the strings beginning with a. The program is supposed to produce bbb, but it never does, no matter how the user waits. And it's supposed to reach a point where the user can be sure that banana will not come out, but it never does that either, it keeps printing as and never prints a string like bbb that comes after banana in lexicographic order.

The problems with lexicographic order are even worse than this example shows. Consider this set of strings:

    b
    ab
    aab
    aaab
    aaaab
    aaaaab
    …

Notice again: not lexicographic order, because b should come out last, not first. But what should come first? A program to print these strings in lexicographic order can't even get started, because in lexicographic order, this list of strings doesn't have a first element! The program can't print out b first because all the a strings were supposed to come out before that. And it can't print out ab first because aab was supposed to come out before that. And it can't print out aaaaaaaaab because aaaaaaaaaaaaaaab was supposed to come out before that. Whatever string the program tries to print out first, it will have made a mistake!

If you're trying to print out an ordered, infinite list of strings, lexicographic order just won't do.

Lexicographic order isn't well-founded

In an earlier article in this series we talked about “well-founded” orders. In a well-founded order, every set of items has a first item, if it has any at all. Writing a productive program for a well-founded order is easy:

Repeat forever:
Question: Are there any items left to print?
No: Halt
Yes:
- Let be the set of unprinted items
- Let be the first item in
  (There must be one, because we're printing the items in a well-founded order)
- Print

As we saw, the conventional lexicographic order is not well-founded for strings. Some sets simply don't have a lexicographically first element.

So in circumstances where we might be handling infinite data streams, we often prefer a different string ordering, almost as simple and considerably better-behaved.

Shortlex order

You already know this one, although perhaps not by that name. It's nothing more than the order we use for regular numerals like 723. It's not lexicographic, because as you've probably noticed, in lexicographic order, 10 comes before 2. Here's the track listing of my copy of Quadrophenia, as listed by the Unix ls program:

    1 I am the sea.mp3
    10 I've had enough.mp3
    11 515.mp3
    12 Sea And Sand.mp3
    13 Drowned.mp3
    14 Bell Boy.mp3
    15 Doctor Jimmy.mp3
    16 The Rock.mp3
    17 Love Reign O'er Me.mp3
    2 The real me.mp3
    3 Quadrophenia.mp3
    4 Cut my hair.mp3
    5 The punk and the godfather.mp3
    6 I'm one.mp3
    7 The dirty jobs.mp3
    8 Helpless dancer.mp3
    9 Is it in my head.mp3

Hey, wait, why did ls put track 17 ahead of track 2? Because ls lists files in lexicographic order, and in lexicographic order, 17 comes ahead of 2 for the same reason that agony and the other ag- words come before bony and the other b- words in the dictionary: 1 comes before 2 just as a comes before b.

If you name your files after numbers, then when the computer lists them in lexicographic order, they won't be in numeric order. Numeric order isn't lexicographic. But numerals, in shortlex order are in numeric order, and of course it's trivial to print all possible numerals in numeric order.

The rule to compare two strings in shortlex order is:

If the strings are different lengths, the shorter one comes first.
If they're the same length, compare them lexicographically.

Compare the shortness first, and use lexicographic comparison as a tiebreaker. Hence “short” + “lex”.

Consider what this means for numerals. Here's a list of binary numerals from to :

It looks strange because it's in lexicographic order — all the numerals that begin with 10 appear before all those beginning with 11, which means that 1000 comes before 11, even though (checking my notes) .

If we want to print all binary numerals in lexicographic order, we're out of luck. The list starts like this:

and we never get to printing any of the numerals starting with 11, including 11 itself.

In shortlex order, it's what we expect. We get the numeral for every number, and in numeric order:

Unlike lexicographic order, the shortlex order is well-founded. Remember that “well-founded” means that every set of strings has a first element. But in lexicographic order, this set of binary numerals has no first element:

In shortlex order there's no problem. There can't be, because shortlex order is numeric order, and if numeric order wasn't well-founded there wouldn't be a productive program to print all the numerals in order, which of course there is.

The infinite lists that we couldn't put into lexicographic order before give us no trouble in shortlex order. In fact, I listed both in shortlex order already:

    a             b
    b             ab
    aa            aab
    bb            aaab
    aaa           aaaab
    bbb           aaaaab
    …             …

For strings, shortlex order is well-founded, which means that every set of strings contains a first element. Here's why: Consider some set and some string . The string has a length . Consider the set of strings that come before . The set must be finite because every string that comes before in shortlex order has length less than or equal to , and there are only a finite number of such strings.

If is empty, then itself is the first string in . If is not empty, then, being finite, it must have a first element. (Just sort .) This first element is the first string in . Done.

Wait, why are there are only a finite number of strings with length less than or equal to ? Well, there are only a finite number of strings of length . (There's only one.) And there are only a finite number of strings of length : If the character set contains symbols, there are only with length . Similarly there are only strings of length , and so on. Since there are only a finite number with each length up to , we just add up this finite list of finite numbers and the sum is finite. And since every string in has length no more than , the number of strings in is at most this finite number.

Coming next: Shortlex order also orders sequences of numbers.

I made Claude sit in a chair in the corner and watch silently while I wrote this.

Magnus Therning: Emacs salmagundi, 2026-08-13

Thu, 13 Aug 2026 19:44:00 +0000

Here's a few minor tweaks I've made to my Emacs setup recently.

Limiting enabled tree-sitter modes

After reading Rahul's post Emacs 31 Is Around the Corner: The Changes I'm Already Daily Driving I simplified my setup and turned on all the tree-sitter modes

(treesit-enabled-modes t)

I regretted that as soon as I opened a YAML file though. It turns out the yaml-ts-mode is rather unusable.¹ I switched back to yaml-mode and adjusted the value of treesit-enabled-modes to include what I have use for (the change):

(treesit-enabled-modes '(bash-ts-mode
                         c++-ts-mode
                         c-or-c++-ts-mode
                         c-ts-mode
                         dockerfile-ts-mode
                         go-mod-ts-mode
                         go-ts-mode
                         go-work-ts-mode
                         json-ts-mode
                         python-ts-mode
                         rust-ts-mode
                         typescript-ts-mode))

The customization of treesit-enabled-modes contains a list of all the supported modes.

I hope someone will take pity on yaml-ts-mode and make it usable soon.

Tree-sitter grammar for Cabal files

When I began tinkering with my own treesitter-based mode for Haskell I failed to find a tree-sitter grammar for Cabal files so I wrote a rather rough one myself. My hope was that it could serve as a base, or motivation, for someone else to write a proper one. It took more than 2 years, but now it's finally happened!

I've switched my mode to use Curtis's grammar and I'll be archiving mine. (The change.)

Hello editable `xref`, good bye `wgrep`

Rahul's post also mentions that editable xref buffers. I had the same itch to have editable xref buffers, and I'd added a function to turn them into grep buffers to be able to edit them. I've now switched to using the built-in support, and removed the function.

At the same time I also decided to remove wgrep and instead use the builtin function for editing grep buffers.

Footnotes:

A mode for an indentation-sensitive language really ought to at least handle indentation!

Mark Jason Dominus: There are two kinds of theorems

mjd@plover.com (Mark Dominus) — Tue, 11 Aug 2026 21:22:00 +0000

In mathematical study there are two kinds of theorems, which serve very different purposes. Math instruction follows the same pattern. Students are often very puzzled by this, and rightly so, because it's never explained, or at least I've never seen it explained. There is this crucial, critical piece of mathematical methodology which is never made explicit, students just have to figure it out on their own, and many of them never do.

When we do mathematics, we construct a simplified model of some phenomenon. For example, Euclidean geometry is a simplified model of how shapes and lines actually work.

In formal geometry, things are simple: lines have no thickness, and three or more lines might all intersect at the exact same point. There are perfect circles, where every point is the exact same distance from the center, and there are perfect rectangles with perfectly straight sides and perfectly equal angles.

Real shapes aren't like this. Nobody can draw an infinitely thin line. Nobody has ever seen a geometrically perfect circle or rectangle. Three lines, however carefully drawn, will always intersect in three different places. That's okay! The point of geometry is to construct a simplified model that is easier to deal with.

When we're setting up a mathematical model, we start by describing its basic objects, like points and lines, and with axioms and postulates, what properties we intend the objects to have. For example, Euclid has:

A line is breadthless length.
A circle is a plane figure contained by one (curved) line with a point inside, the center, so that the segments from the center to the boundary of the circle are always of equal length
All right angles are equal.

Having done that, we state and prove the theorems of the first kind. We're not studying the actual phenomenon yet. We're not yet trying to learn anything new about shapes and circles. Instead, we're investigating the model itself:

Is the model accurate? Does it seem to lead to wrong conclusions? What happens if we try to prove things that we know are are false? The proofs should fail! If they don't, something is wrong with the model, and we need to fix it.
Is the model powerful enough to prove at least simple things about the actual phenomenon? If it can't encompass the simple aspects of the phenomenon, we haven't much hope of using it to understand more complex aspects.

So for example Euclid starts by proving extremely simple theorems. For example, propositions 4 and 5:

Proposition 4: If in triangles and we have and and , then the two triangles are congruent.

Proposition 5: If two straight lines cut one another, then they make the vertical angles equal to one another.

(That is, and .)

Obviously, yes, anyone can see that! We didn't need to develop a whole mathematical theory in order to discover that vertical angles were equal. Everyone already knew that, long before Euclid. The point of proving this theorem, the real discovery, is: our simple model is strong enough to demonstrate that vertical angles are equal. The theory didn't explicitly include anything about vertical angles, but the vertical angle theorem was latent in the model anyway.

Consider the opposite situation, where we couldn't prove that vertical angles were equal. Or worse, what if the model allowed us to construct a pair of unequal vertical angles? Would this tell us something about vertical angles? Obviously not. Vertical angles are equal, regardless of what the theory does or doesn't prove. It would, though, tell us something about the theory, namely that it wasn't fit for purpose, and we'd better try a different model.

This is a common pattern in all mathematics education and indeed in all mathematics, but I've rarely seen it called out as such, not even with a passing remark like “here's why we're doing this”. In nearly every undergraduate class I've ever been in, someone was puzzled about why we were doing this. Why is Euclid proving all these theorems that are obvious?

In Euclid the mode goes back and forth: Euclid will do some model-verifying theorems, then move on to interesting-result theorems, then back for a while to introduce something new to the model, then forward again to prove interesting theorems about the thing he introduced. The first transition happens around proposition 32 or 36 or so. Up until that point there were a lot of proposition like this:

Proposition 20 In any triangle the sum of any two sides is greater than the remaining one.

and this:

Proposition 25 If two triangles have two sides equal to two sides respectively, but have the base greater than the base, then they also have the one of the angles contained by the equal straight lines greater than the other.

But then very soon after, the theorems start to have a different flavor:

Proposition 36: Parallelograms which are on equal bases and in the same parallels equal one another.

That is:

This is actually an interesting fact about parallelograms, and not intuitively obvious. Even though the two parallelograms are not at all the same shape, they have equal areas, since they lie between the same parallels and . (Interactive version)

The same issue comes up in many different contexts. We develop the theory of the Peano numbers, define addition, and prove that addition is commutative, Was that because we didn't know how to do addition? No. We already knew that addition was commutative. The point of the theorem is to show that Peano arithmetic knows that addition is commutative. But I have more than once seen instructors demonstrate the proof, via a double induction, and then finish with a remark like “therefore, addition is commutative!” The students, to their credit, were suspicious of this. They knew something wasn't quite right, even if they weren't sure what. The right announcement would have been something like “therefore, the Peano axioms aren't complete rubbish!”

Or: We explore Dedekind cuts, we define a model for the real numbers as cuts of rationals, and a construction that we claim characterizes addition. And then we prove a batch of theorems that are intended to show things we already know about addition, not because we want to know whether addition is commutative (news flash: it is) but to show that it's plausible that our construction really does characterize addition. One of these, that the addition operation we defined on cuts, which looks nothing like the addition we defined on rational numbers, actually agrees with it when the cuts themselves correspond to rationals. Another, that if then .

Taking a look at Rudin Principles of Mathematical Analysis, I see that the first fifteen or so pages are like this, theorems like , which is a basic property of the fundamental notions and . And then the mode starts to shift, first a little bit, with

Let and be complex numbers. Then

Okay, that's a triangle inequality again… and suddenly, seemingly out of nowhere, something not at all obvious: Theorem 1.35, the Cauchy-Schwartz inequality for :

$$ \left\lvert\sum_{j=1}^n a_j\bar b_j\right\rvert ^2 ≤ \sum_{j=1}^n\lvert a_j\rvert^2 \sum_{j=1}^n\lvert b_j\rvert^2 $$

A completely different kind of theorem, not a basic property of anything.

Remember the whole point of the process: We wanted to model some object of study, we built a model, we proved a lot of theorems to lend plausibility to our model, to verify that the model wasn't broken, to confirm that the model captures the properties of interest. And then came time to use the model, and we started to prove theorems that told us new things about the original object of study.

Does Rudin announce this shift? Of course not, Rudin never announces anything. (Usually he mutters, and sometimes if you are especially unlucky he fixes you with a glare that dares you to question the remark he throws away in an undertone.) But Rudin is Rudin, and nobody else seems to announce this shift either. Almost always, it's passed over, usually without remark, even in gentler textbooks that give more attention to pedagogical matters. Sometimes the shift is sudden, sometimes gradual, but it's almost never pointed out.

In advanced study, that's okay, because advanced students should be expected to recognize the pattern. But why do we expect high schoolers and undergraduates to understand this without explanation?

In summary:

There are two kinds of theorems.
- The purpose of the first kind is to validate the model we've built, to check it for power and correctness.
- But the second kind is the kind we're really after, to apply the model to the problem we want to study.
This pattern, of building a model, validating it, and then using it, is a fundamental and universal methodology in all mathematical study.
Secondary and tertiary mathematical education should explain this methodology, but rarely acknowledges it at all.

I asked Claude to do the diagram with the triangles, but I didn't like the result and changed it all around in Inkscape. Then I gave it the changed around version and asked it to do the diagram with vertical angles in the same style, but I didn't like the result and changed it all around in Inkscape.

The diagram with the parallelograms is a screencap from Desmos. I couldn't figure out the Desmos geometry tool, so I had Claude walk me through how to make the diagram, then tinkered with the result.

Abhinav Sarkar: Fast Haskell Scripts on GitHub Actions

abhinav@abhinavsarkar.net (Abhinav Sarkar) — Mon, 10 Aug 2026 00:00:00 +0000

Magix is a neat tool that lets us run Haskell programs as scripts¹. We put a shebang on top mentioning Magix, list the Haskell packages we need, and ./script.hs just works. This post is about running such a script fast(er) on GitHub Actions.

This post was originally published on abhinavsarkar.net.

The Setup#

As our example, we’ll take the static site generator (SSG) I wrote some time ago: BlogShake. It is written as a single Haskell file. It uses Shake to build the website, Pandoc to render posts, and Mustache for templates. The script starts with these Magix directives²:

#!/usr/bin/env magix
#!magix haskell
#!haskellPackages mustache pandoc shake feed yaml
#!ghcFlags -threaded -O2

Running the script is as simple as:

./blog.hs

Magix compiles the script into an executable and runs it. Nothing else to install, no cabal, or nix-shell required.

Nix and Cabal can also run scripts by providing shebang directives³, so why reach for Magix instead? The nix-shell shebang reinterprets the script with runhaskell on every run, which is slow. Cabal compiles the script, but it fetches dependencies from Hackage and builds them from source, leading to very slow first build and rebuilds. Magix compiles the script once into a binary executable and caches it for the next runs. It also fetches dependencies from the prebuilt Nix cache. So running via Magix is faster than either case. But when running on GitHub Actions, we have a problem.

The Problem#

GitHub Actions gives us a fresh runner for every build, with no Nix store and no Magix cache. So every run, we have to install Nix and Magix, download all the dependencies, and compile the script. In one instance, the build from scratch took 105 seconds, with installation, dependency download, and compilation taking 92 seconds.

That is a lot of wasted work because the script and its dependencies change rarely. The actual run itself takes only a few seconds once the executable exists.

The Idea#

What if we could persist the compiled executable across runs? Magix’s build is deterministic: the same script and the same nixpkgs revision produces the same executable. If we could stash that executable somewhere durable, a cache hit could skip Nix and Magix installation, as well as the script compilation entirely, and just run the executable.

Magix creates a Nix derivation for compiling the Haskell script with GHC and builds it. The resultant executable lives in Magix’s cache, as a symlink with a path like:

$ readlink -f ~/.cache/magix/*blog-result
/nix/store/<hash>-blog

GHC statically links all the Haskell libraries into the executable. The only dynamic dependencies are a handful of libraries—zlib, libffi, gmp etc. So if we have the executable plus those few libraries as a self-contained unit, we don’t need the hundreds of other packages in the Nix store⁴.

The Bundle#

I wrote a small script, magix-bundle.sh, with two subcommands:

$ magix-bundle.sh bundle blog.hs     # creates a bundle
$ magix-bundle.sh run blog.hs build  # runs a bundled script

The script works for any Magix script, not just blog.hs. Let’s go through it.

The script takes a command and a script file, derives the bundle name from the script file name, and resolves the directories it needs:

set -euo pipefail

if [ "$#" -lt 2 ]; then
  echo "usage: magix-bundle.sh <bundle|run> <script-file> [args...]" >&2
  exit 1
fi
CMD="$1"
shift
SCRIPT_FILE="$1"
shift

[ -f "$SCRIPT_FILE" ] || {
  echo "error: script not found: $SCRIPT_FILE" >&2
  exit 1
}

NAME=$(basename "$SCRIPT_FILE")
NAME=${NAME%.*}
HASH=$(sha256sum "$SCRIPT_FILE" | awk '{print $1}')
MAGIX_CACHE="${MAGIX_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/magix}"
DEST="${MAGIX_BUNDLE_DIR:-$HOME/.cache/magix-bundles}/$HASH"

NAME is the script file name without its extension, and HASH is a SHA-256 hash of the script contents; together they key the bundle directory. MAGIX_CACHE mirrors how Magix itself resolves its cache directory: $XDG_CACHE_HOME/magix or ~/.cache/magix, overridable with the MAGIX_CACHE_DIR environment variable. Bundles live under ~/.cache/magix-bundles by default, overridable with the MAGIX_BUNDLE_DIR env var.

Creating the Bundle#

The bundle function locates the script’s build result in Magix’s cache, copies the executable out of the Nix store, and gathers the libraries it links against:

copy_lib_deps() {
  local src="$1"
  local deps dep base
  deps=$(ldd "$src" | awk '/\/nix\/store\//{print $3}')
  for dep in $deps; do
    case "$dep" in
      */*-glibc-*/*) continue ;;
    esac
    [ -e "$dep" ] || {
      echo "error: dependency '$dep' of '$src' not found" >&2
      exit 1
    }
    base=$(basename "$dep")
    if [ ! -f "$DEST/lib/$base" ]; then
      cp -L "$dep" "$DEST/lib/$base"
      copy_lib_deps "$dep"
    fi
  done
}

bundle() {
  mkdir -p "$DEST/bin" "$DEST/lib"

  RESULT=""
  for f in "$MAGIX_CACHE/"*"-$NAME-result"; do
    [ -L "$f" ] || continue
    [ -e "$f" ] || continue
    if [ -z "$RESULT" ] || [ "$f" -nt "$RESULT" ]; then
      RESULT="$f"
    fi
  done
  [ -n "$RESULT" ] || {
    echo "error: no build result for '$SCRIPT_FILE' found in $MAGIX_CACHE" >&2
    exit 1
  }

  RESULT=$(readlink -f "$RESULT")
  BIN="$RESULT/bin/.$NAME-wrapped"
  cp "$BIN" "$DEST/bin/$NAME"
  chmod +w "$DEST/bin/$NAME"

  copy_lib_deps "$BIN"

  case "$(uname -m)" in
    x86_64)
      INTERPRETER=/lib64/ld-linux-x86-64.so.2
      ;;
    aarch64)
      INTERPRETER=/lib/ld-linux-aarch64.so.1
      ;;
    *)
      echo "error: unsupported architecture: $(uname -m)" >&2
      exit 1
      ;;
  esac

  patchelf \
    --set-interpreter "$INTERPRETER" \
    --set-rpath "\$ORIGIN/lib" \
    "$DEST/bin/$NAME"

  for lib in "$DEST"/lib/*; do
    [ -f "$lib" ] || continue
    chmod +w "$lib"
    patchelf --set-rpath "\$ORIGIN" "$lib"
  done
  echo "bundle created at $DEST"
}

Here is what it does:

It picks the latest <hash>-<name>-result symlink for the script by modified time, skipping dangling ones⁵.
It dereferences the symlink to a Nix store path, copies the compiled executable at bin/.<name>-wrapped from the Nix store path into the bundle⁶, and makes the copy writable.⁷.
It copies the dynamic library dependencies of the executable by calling the function copy_lib_deps. copy_lib_deps finds the dependencies with ldd, and copies the ones that live in /nix/store into the bundle’s lib/ directory, skipping glibc. Note that it does this recursively, copying the dependencies of dependencies as well.
It rewrites the executable with patchelf, setting the interpreter and the library search path for it. It also sets the library search path for libraries themselves so that transitive dependencies work as well.

The two patchelf flags are the interesting part. The --set-rpath flag makes the dynamic loader find the bundled libraries, so we don’t need LD_LIBRARY_PATH or the Nix store at run time. The --set-interpreter flag is needed because Nix rewrites each executable’s dynamic loader to point at its own glibc inside the Nix store. Since we don’t bundle glibc, we reset the interpreter to the host’s loader according to the system’s architecture⁸.

Bundling glibc?#

We deliberately do not bundle glibc. Unlike the other libraries, glibc cannot simply be shipped alongside the executable⁹. The dynamic loader needs to be at an absolute path and needs to be matched with the glibc version. So we simply don’t bundle it and rely on the host’s glibc. One caveat here is that the host’s glibc must be at least as new as the one the executable was built against. That works because glibc is backwards-compatible¹⁰.

Running the Bundle#

The rest of the script is the run subcommand and the command dispatch:

run() {
  local bin="$DEST/bin/$NAME"
  if [ ! -f "$bin" ] || [ ! -d "$DEST/lib" ]; then
    echo "error: no bundle for '$SCRIPT_FILE' at $DEST" >&2
    exit 1
  fi
  exec "$bin" "$@"
}

case "$CMD" in
  bundle)
    if [ "$#" -gt 0 ]; then
      echo "error: 'bundle' takes no extra arguments" >&2
      exit 1
    fi
    bundle
    ;;
  run) run "$@" ;;
  *)
    echo "error: unknown command '$CMD' (expected 'bundle' or 'run')" >&2
    exit 1
    ;;
esac

run computes the same SHA-256 hash of the script, checks that the bundle exists, and execs the executable, passing the remaining arguments through untouched.

The GitHub Actions Workflow#

The workflow uses Nix, Magix and the bundler script to execute the Haskell script.

First, we set the runner image and the nixpkgs branch we track¹¹:

name: Build blog

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  build:
    name: build
    runs-on: ubuntu-26.04
    env:
      NIXPKGS_BRANCH: release-26.05

The next two steps compute the cache key and restore the bundle if we have one:

    steps:
      - name: checkout
        uses: actions/checkout@v6
        with:
          ref: main

      - name: resolve nixpkgs commit
        id: nixpkgs
        run: |
          set -euo pipefail
          SHA=$(git ls-remote https://github.com/NixOS/nixpkgs.git "refs/heads/$NIXPKGS_BRANCH" | cut -f1)
          echo "sha=$SHA" >> "$GITHUB_OUTPUT"

      - name: cache blog bundle
        id: cache-blog
        uses: actions/cache@v5
        with:
          path: ~/.cache/magix-bundles
          key: magix-bundles-${{ hashFiles('blog.hs') }}-${{ steps.nixpkgs.outputs.sha }}

We resolve the nixpkgs branch to its latest commit with git ls-remote at the start of the job, use that commit in the cache key, and pin the whole build to the same commit via MAGIX_NIXPKGS_REF, as we see below.

The cache key has two parts: the hash of the script and the resolved nixpkgs commit hash. When the branch moves or the script changes, the cache misses because of the key change, and we rebuild against the new commit and/or script. We also restore the previously cached bundle to ~/.cache/magix-bundles, if found.

The next four steps run only on a cache miss:

      - name: install Nix
        if: steps.cache-blog.outputs.cache-hit != 'true'
        uses: DeterminateSystems/nix-installer-action@v22
        with:
          extra-conf: |
            extra-substituters = https://dschrempf-magix.cachix.org
            extra-trusted-public-keys = dschrempf-magix.cachix.org-1:cScG6NjZBiQvY7KjSPpQdUa9UXZVLz9rvUZHtuwdYwc=

      - name: install magix
        if: steps.cache-blog.outputs.cache-hit != 'true'
        run: nix profile install github:dschrempf/magix

      - name: compile blog
        if: steps.cache-blog.outputs.cache-hit != 'true'
        env:
          MAGIX_NIXPKGS_REF: github:NixOS/nixpkgs/${{ steps.nixpkgs.outputs.sha }}
        run: ./blog.hs

      - name: create bundle
        if: steps.cache-blog.outputs.cache-hit != 'true'
        run: ./scripts/magix-bundle.sh bundle blog.hs

install Nix adds Magix’s binary cache to Nix, so that we get the prebuilt packages for Magix. The compile blog step runs ./blog.hs with no arguments¹²: This causes Magix to compile the script, but Shake has nothing to build, so it exits immediately. The build is pinned to the same nixpkgs commit that keys the cache, via the MAGIX_NIXPKGS_REF env variable used by Magix. Finally, create bundle packages the compiled executable by running the bash script we saw earlier.

The rest of the workflow runs on every run, cache hit or not:

      - name: build site
        run: ENV=PROD ./scripts/magix-bundle.sh run blog.hs -j4 build

I’ve cut down the rest of the workflow to the only step that is relevant to us: build site that runs the bundled executable with the script’s arguments. Other steps are specific to BlogShake.

The Payoff#

All of this work, what does it buy us? Here are two numbers:

Build with no bundle: 1 min 45 sec.
Build with cached bundle: 10 sec.

With the cached bundle, the runner just downloads it and runs the executable, skipping Nix and Magix installation and script compilation altogether.

The Conclusion#

This post showed how to speed up a Haskell script running on GitHub Actions by caching a compact bundle of its compiled executable. The approach works for any Haskell script that runs on Linux: compile once using Magix, bundle the binary with its library dependencies, and let the cache do the rest. One caveat though: the bundler script uses the internal details of Magix, which may break if Magix changes how it works.

The full source code:

If you have any questions or comments, please leave a comment below. If you liked this post, please share it. Thanks for reading!

At the point of writing this post, Magix supported Bash, Haskell, and Python.↩︎
Because the executable is compiled once and run many times, we build the script with -O2.↩︎

The shebang-based alternatives look like this:

#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (p: [p.pandoc p.shake p.mustache p.feed p.yaml])"
#! nix-shell -i runhaskell

for Nix, and:

#! /usr/bin/env cabal
{- cabal:
build-depends: base, pandoc, shake, mustache, feed, yaml
-}

for Cabal.↩︎

Why not cache the entire Nix store between runs? Because the size of the full Nix store closure required to build Haskell scripts is usually in GBs. Caching that per run would defeat the purpose of caching by taking way too much time to download the cache. You may also want to reach out for the Nix bundle feature, which produces self-contained compressed executables. But these executables are still too big: 45 MB compressed/178 MB uncompressed for BlogShake. Our approach in this post results in a 9 MB bundle, compressed.

Another completely different option is to build a fully statically linked executable, which I wrote about in Nix for Haskell: Static Builds. However, that requires a custom toolchain, running which on GitHub Action is too complex and/or slow.↩︎
A result symlink can be left dangling if the store path has been garbage-collected. We skip those and pick the newest live one.↩︎
Magix wraps the built executable with wrapProgram, which renames the real executable to bin/.<name>-wrapped and puts a wrapper script in its place. We copy the real executable.↩︎
Nix store files are read-only mode, and we are about to modify the file, so we make it writable.↩︎
We hardcode the loader paths here, but it should work on most mainstream Linux distributions with glibc.↩︎
Well, it can be actually. That’s what Nix bundle does. It copies the glibc in the Nix store to the bundle, and points the program interpreter at the bundled loader inside a chroot.↩︎
An executable built against glibc 2.42 runs fine on a host with glibc 2.43, but not the other way around.↩︎
The glibc constraint dictates the runner image. Here we build against nixpkgs branch release-26.05, which has glibc 2.42. Ubuntu 26.04, the GitHub runner image we use, ships with glibc 2.43. So they are compatible.↩︎
That no-argument behavior is Shake-specific: with no actions given, Shake runs nothing, so a bare ./blog.hs compiles the script and exits. A general script won’t do that by default. If you adapt this for a non-Shake script, give it a mode that does nothing, say a --compile flag, so running it bare just produces the executable. This step’s only job is to get Magix to build the script, not to run it.↩︎

Thanks for reading this post via feed. Feeds are great, and you're great for using them. ♥

This post was originally published on abhinavsarkar.net.

Like, repost, or comment on:

Oskar Wickström: How Antithesis Found and Explained a Bombadil Race Condition

Thu, 06 Aug 2026 22:00:00 +0000

Disclosure: I’m the original author and lead for the Bombadil project at Antithesis.

Carlos Catala, interning at Antithesis and working on testing our webapps, found a strange crash while I was out camping. The tests he works on runs Antithesis’ webapp inside Antithesis and explores it using Bombadil. That surfaced a particular sequence of events leading up to the following crash (logs are simplified for readability):

state machine error: unhandled transition: Running(10) + ActionAccepted(Click("Filters"))

What does this mean? To understand it, we need to back up a little.

The heart of the browser driver is a finite state machine, an abstract model of a tab in Chrome or Chromium, and how we’re interacting with it over CDP. This is necessary due to how you can only invoke certain commands in certain browser states, or it might hang or behave in other confounding ways. In our state machine, some transitions are valid, and those are handled in a big match (state, event) { ... } expression that returns a new state. Invalid transitions are covered by the last branch that returns an Err with a message like the above.

There’s another important component involved which is called the runner. It decides the control flow of the test, and uses the driver to run the system under test. The driver emits a state, and the runner decides what action to take in that state. It hands back the action to the driver so that it can apply it. The browser driver actually pauses the JS runtime when capturing a state, and doesn’t resume execution until the driver has given back the next action.

Hence, the ActionAccepted event (which is when the driver gets a new action from the runner) is not valid in the Running state. It really is only valid in the Paused state. How could this happen? The driver and runner are supposed to operate in lock-step, where the driver is only in control while the JS runtime is paused. This was the nut to crack.

When Carlos told me about this during my PTO, my camping brain was definitely not helpful, so I let it rest until I was back at work. Staring at logs and code also didn’t help much, except for a poorly conceived theory about what could be going on, mislead by the presence of network faults in one test where we saw the bug. We tried but failed to reproduce this locally, so I decided to find a simpler test subject and, crucially, try to reproduce it in Antithesis.

A Simple Reproduction with Causality Analysis

To reduce possible confusion I wanted to first see if I could trigger the same bug in Bombadil with a simpler system under test. I found a Dockerized version of the-internet, an example application by Sauce Labs made for automated browser testing. Based on what we had seen before, I wrote a very small specification that only performs three actions:

export * from "@antithesishq/bombadil/browser/defaults/properties"; import { weighted } from "@antithesishq/bombadil/browser"; import {  back,  forward,  clicks, } from "@antithesishq/bombadil/browser/defaults/actions";  export const navigation = weighted([  [1, clicks],  [1, back],  [1, forward] ]);

In addition to finding various bugs in the Ruby code, it also immediately reproduced the Bombadil bug! Time to dig in. I went through a few instances and started to see a pattern. In addition, this gave me an excellent opportunity to try out Causality Analysis, a mind-bending feature for learning what behavior increases the likelihood of a bug appearing. Here’s the report I got:

The causality analysis report plots the likelihood and helps you understand what events caused a certain bug.

As you may see in the chart, there are three points where the probability increases markedly. Correlating those with the logs (which is easy, you see the bumps highlighted in the log too), I could find the chain leading up to the bug:

Click a link that navigates to /frames (probability goes to 20%)
On that page, click a link that navigates to /iframe (probability goes to 47%)
Go back (I was a bit surprised that this didn’t bump probability noticeably)
Go forward (probability goes to 99.98%)

After the last “Go forward” action, it’s a done deal. Digging into the details in between these points, I could then see how going back to a page which immediately throws an exception, after restoring from bfcache, takes a different path than most page loads do.

The Bug

When going back or forward in history, the state machine immediately transitions to Running, waiting for confirmation by the browser to know what actually happened. Some pages prevent bfcache through JavaScript or HTTP headers, so a history navigation can also end up as a full page load with new HTTP requests. When the page is confirmed to have been restored from bfcache, the page and thus the state machine model skips the Loading state entirely, and goes straight to Running.

In this case, that was followed by the exception being thrown immediately (you can see it in the bottom of the screenshot above), which triggers another path: exceptions thrown while in Running aren’t collected and reported at a later state capture, as is the case for the Loading state — they immediately pause the runtime and trigger a new state read. This in turn let the runner pick a new action to perform. But the CDP event that confirms that the page was restored from bfcache hadn’t arrived yet.

This is a race between the asynchronous communication of runner and browser state machine, selecting the next action, and the CDP event sent by Chromium over a WebSocket confirming the bfcache restore. The unfortunate ordering that triggers the bug is:

Back or forward, restoring from bfcache
Exception thrown on restored page, pausing the debugger and capturing a new state
Runner picking a new action and passing it back to the browser state machine
Confirmation of bfcache restoration coming in, transitioning state machine to Running
State machine applying the ActionAccepted event, which, as we noted in the beginning of this excursion, is not valid when in Running

This sequence causes the crash. It only happens with bfcache-enabled history navigation to a page with an exception being thrown before the confirmation from Chromium comes back. Antithesis’ deterministic fuzzing environment messes with process scheduling and action selection and discovers this sequence reliably.

In Conclusion

I’m not going to describe the fix in too much detail, but it involves a more robust use of the already existing Generation value in the browser state machine. It’s a monotonically increasing number that is used to detect stale timeouts and actions, so that the state machine can discard them. The browser state now carries the current generation, and that is threaded through the runner’s action selection process, so that a stale action (as in step 5 above) can be safely ignored. Additionally, some transitions now increment the generation in cases where all existing timeouts or actions are stale.

I’ve had bugs of this kind before, and understanding them from staring at logs, let alone reproducing them, has been painful. This, in contrast, feels a bit like cheating. Moreover, it extends to race conditions and complicated bugs in the webapps themselves, which makes me very excited about continued work on the Bombadil and Antithesis integration.

Mark Jason Dominus: The road to epsilon-zero: Coin-moving games with no coins

mjd@plover.com (Mark Dominus) — Wed, 05 Aug 2026 19:27:00 +0000

Previously:

In the previous article we saw how to interpret Nim heaps of up to beans as coins on a quarter-infinite array:

The coin here represents a heap of beans. The heap can be reduced to any smaller number of beans. In the coin version of the game, this corresponds to moving the coin to any square to the left in the same row, or to any square in any lower row.

To extend this past , though, was a little clumsy. We had to pile up an infinite stack of these grids, and that got us only to . Then to go further we had to move into the fourth dimension, and to get all the way to we had to imagine a sort of discrete Hilbert space with an infinite number of dimensions, not easy. I personally have trouble imagining anything with more than about dimensions, and an infinite number of dimensions is a couple more than I can handle comfortably.

We can do better. Instead of imagining a grid of squares with coins on the squares, just write the coordinates of the coin! The one above, representing a pile of beans, is simply $$⟨2, 3⟩.$$

A game of infinite Nim is now simply a list of these pairs, one for each coin. A legal move is to pick one of the pairs and:

reduce the first coordinate, which corresponds to moving the coin to the left in the same row, or
reduce the second coordinate (which moves it to a lower row) and replace the first coordinate with any number at all, even a larger one (any square in the lower row is allowed)

Moving from to uses the first rule to reduce the first coordinate from to . Moving from to uses the second rule to reduce the second coordinate from to and simultaneously replace the first coordinate with , leaving the coin on .

Removing the entire pile uses the second rule to reduce the second coordinate from to and simultaneously replace the first coordinate with , yielding .

To stack up multiple grids no longer requires third dimension, just a third coordinate. To make it compatible with the two-coordinate notation, we just agree to understand as an abbreviation for . The move rule generalizes to:

Pick any nonzero coordinate
Reduce it by at least 1
Replace any coordinates to the left of that one with any numbers at all

For example, we can move from to (the has decreased), or from to (the has decreased).

To go into the fourth dimension and beyond is similarly easy: just allow a list of coordinates of any finite length, and use the same rule as above: reduce any single coordinate, and simultaneopusly replace any or all of the coordinates to its left.

For example, is now represented as . We can also imagine there is a trailing sequence of zeroes, of either finite or infinite length, but they don't affect the game.

Maybe it's easier to see now why this enormous nim-heap must eventually be removed. On the first move, someone must either reduce that or else one of the numbers to the right of it. But the players can't indefinitely put off reducing one of the other numbers; if they work only on the , then after at most they will have arrived at , and then someone must reduce one of the other numbers, since moves from aren't allowed.

The can be increased, but only at the cost of reducing a farther-right number. But that's true of every number except the final . And however long the players avoid reducing that final , by reducing numbers farther left — and it might be a very, very, very long time — eventually they will get to and won't be able to put it off any longer.

To get ordinals up to is straightforward: they correspond directly to finite sequences of numbers, with the moving rule described above: sequence represents an ordinal less than sequence if one of 's elements is less than the corresponding one of 's, and the elements to the right are the same.

I hd said at one point that was where the ordinals started to get scary. And perhaps it does seem scary, if you try to think of it as cells in an infinite-dimensional array. But when you think of as just the set of finite sequences of numbers, it's not scary at all!

That was my first big step on the road to , but seems much more daunting. It's not merely , it's actually more like

$$ω^{ω^{ω^{ω^⋰}}}$$

because it's by definition the smallest ordinal with the property that . But the next couple of articles will take us the rest of the way there!

Coming next:

You can write a program to print an infinite list of strings, but you can't always write one to print them in alphabetic order: Productive programs and well-founded orders
Shortlex order also orders sequences of numbers

The gold dollar coin in the first illustration started out as an SVG provided by Claude, but underwent signficant transformation at my hands in Inkscape. All other slop in this article is entirely the product of my own natural intelligence.

Philip Wadler: Just Work: The Gig Economy, Platform Capitalism and the Battle for Worker Rights

noreply@blogger.com (Philip Wadler) — Wed, 05 Aug 2026 14:43:48 +0000

A comic by Tom Humberstone about gig workers and the need to organise, with loads of local Edinburgh flavour.

in Code: "Five-Point Haskell": Unconditional Election (via Parametricity)

Tue, 04 Aug 2026 18:15:09 +0000

Welcome back to Five-Point Haskell! This is my attempt to codify principles of writing robust, maintainable, correct, clear, and effective code in Haskell and to dispel common bad practices (or, heresies) I have run into in my time.

In the last post, we talked about Total Depravity, which is about treating any mentally tracked constraint or condition as inevitably leading to a catastrophe and denouncing the reliance on our flawed mental context windows.

However, stopping here gives us an incomplete picture. Firstly, types aren’t just about preventing bad behaviors. They’re about designing good code. Secondly, there is only so much you can do by picking careful structures and making invalid states unrepresentable. These are still human tools with human flaws.

The next point, to me, is about an aspect of the type system that I see little coverage of, but is a doctrine of design that I reach for in almost everything I write. It’s about leveraging the unyielding properties of math itself to take care of our fate, even when we are unable to structure our types well.

So, when writing Haskell, remember Unconditional Election.

Unconditional Election: The power of the forall to elect or reprobate instantiations and implementations through parametric polymorphism. These properties aren’t based on any conditional ad-hoc aspect of types, but are truly unconditional, predestined by universal quantification.

Surrender your control to parametric polymorphism in all things. Embrace the “free”-dom of “Free Theorems” from one of Haskell’s greatest unexpected strengths: the type parameter.

Choice is a Prison

Conditional Election

Learning Haskell can be a journey full of surprises, but this was one of the ones that blew my mind the most.

Let’s think of a polymorphic function in Java that takes a value of any type and returns something of that same type:

static <T> T foo(T x)

What could that function do?

Well, it could do IO or throw an exception, mutate the input, or possibly be non-terminating, but let’s assume all it (and every other example here) does is purely return a value without mutation. What could it do?

The answer: pretty much anything. It could return the same value it was given, except if it is an Integer, in which case it negates it:

static <T> T foo(T x) {
  if (x instanceof Integer i) {
    return (T) Integer.valueOf(-i);
  }
  return x;
}

Same deal in TypeScript or pretty much any other typed language without parametricity:

function foo<T>(x: T): T

Yet again, we have conditional election:

function foo<T>(x: T): T {
  if (typeof x === "number") {
    return (-x) as any as T;
  }
  return x;
}

But how about Haskell?

foo :: a -> a

(For the rest of this post, let’s ignore non-termination ¹ and other escape hatches²)

Because Haskell has type erasure and no runtime reflection, the only possible implementation is simply:

foo :: a -> a
foo x = x

So, there is an invariant that appeared somehow in our code: a function of type forall a. a -> a must leave its value unchanged!

But wait…says who? Did we insert some sort of const compiler annotation? Did we add some sort of annotation or pre- and post-condition that the value cannot change? Are we relying on any sort of foreseeable property of the value given?

No, this behavior is actually intrinsically fixed! We got this theorem for free. No need for any sort of work, no need for any foreseen faithfulness. We didn’t even have to write the function before knowing all it possibly could be.

This is the power of the forall. The above foo :: a -> a can be considered “sugar” for:

foo :: forall a. a -> a

If you don’t add a forall a, it is implicitly added. Some languages, like PureScript and Dhall, require the forall in every case to be explicit. You can think of the “forall” as like template <typename T> in C++, a declaration of what type variable is being quantified over.

Anyway, let’s consider another type signature:

static <T> String foo(T x)

Even if we disallow IO (like getting the time, or system state), in Java (and most other languages), this again could literally be anything. You can serialize the object with toString, or you can get its class using getClass…

static <T> String foo(T x) { return "hello"; }
static <T> String foo(T x) { return x.toString(); }
static <T> String foo(T x) { return x.getClass().getSimpleName(); }

In Haskell? A forall a. a -> String cannot use its input! It must be a constant string!

foo :: a -> String
foo _ = "hello"
-- or
foo _ = "goodbye"
-- or
foo _ = "i always ignore my input"

In fact, there is an isomorphism between String and forall a. a -> String (fun exercise: write it!)

You can “selectively” bring in capabilities using typeclasses:

foo :: Show a => a -> String
foo _ = "hello"
-- or
foo x = show x
-- or
foo x = "reversed: " <> reverse (show x)

But there are still properties you can enforce: the resulting string can only depend on the input as far as what is revealed in its Show instance. Any property not in its Show instance is off-limits.

Alternatively, you can think of foo :: Show a => a -> String as:

foo :: (a -> String) -> a -> String
foo showVal x = -- ...

and you can see that the only way you can ever inspect a is through the singular inspection-lens a -> String that you are given. No getClass(), no back doors, etc.

The Guessing Game

One game Haskellers often play day-to-day is “guess the properties that the forall ensures” on different type signatures. Let’s try it out!

For example:

mystery :: a -> b -> a

mystery has to be \x _ -> x — there is no other option.

How about:

turmeric :: ((a, b) -> c) -> a -> b -> c

If you think about it, the only option is:

turmeric :: ((a, b) -> c) -> a -> b -> c
turmeric f x y = f (x, y)

You can go pretty far down this lane using Haskell as a theorem prover, in that the type signature represents a proposition and the implementation represents a proof of that claim. But we’re not going to go down that route for now, since most practical code is not theorem-proving.

But let’s look at something a bit more structural. How about:

theThing :: [a] -> [a]

What could this do?

Well, we know that all items from the result list must be from the input list. It must be a “subset” — but the ordering or multiplicity can change. And more importantly, it can’t depend on anything about the properties of any a. We also know that if the input is empty, so must be the output.

From this, we can derive what are called free theorems to look at properties that any implementation must have. Namely, mapping a function over the list and calling theThing must be equivalent to calling theThing and then mapping:

theThing . map f
  == map f . theThing

Can you see why? Think of any possible implementation — reverse, take 3, etc. — and see how this must be the case. However, this is not true for i.e. sort :: [Int] -> [Int]. Because sort depends on the actual properties of the items, map f could change the properties that sort depends on!

ghci> sort . map abs $ [5,-1,3,-7]
[1,3,5,7]
ghci> map abs . sort $ [5,-1,3,-7]
[7,1,3,5]

Compared to an actual function with the polymorphic type, like take 3:

ghci> take 3 . map abs $ [5,-1,3,-7]
[5,1,3]
ghci> map abs . take 3 $ [5,-1,3,-7]
[5,1,3]

How about:

doIt :: [a] -> Maybe a

Think about what this can’t do. It clearly selects a single item, but:

The single item cannot be determined based on any quality or merit of that item — it can’t be the smallest, the largest, etc.; it has to depend purely on the position in the list and the length of the list
If given an empty list, it must return Nothing

And again we have the same free theorem, doIt . map f == fmap f . doIt. No matter how you implement doIt, it is guaranteed to commute with map and fmap!

-- no free theorem: `minimumMay :: [Int] -> Maybe Int`
ghci> minimumMay . map abs $ [5,-1,3,-7]
Just 1
ghci> fmap abs . minimumMay $ [5,-1,3,-7]
Just 7

-- free theorem: `listToMaybe :: [a] -> Maybe a`
ghci> listToMaybe . map abs $ [5,-1,3,-7]
Just 5
ghci> fmap abs . listToMaybe $ [5,-1,3,-7]
Just 5

-- free theorem: `lastMay :: [a] -> Maybe a`
ghci> lastMay . map abs $ [5,-1,3,-7]
Just 7
ghci> fmap abs . lastMay $ [5,-1,3,-7]
Just 7

Let’s try another one:

collapse :: [a] -> Int

What could this possibly do? Well, we can rule out things like sum because we can’t use any property of the values themselves. The only things that this could return are constant functions and functions that depend on the length but not the contents of the list. We also have another free theorem, collapse . map f == collapse: mapping a function shouldn’t change the output, because none of the actual values matter.

-- no free theorem: `sum :: [Int] -> Int`
ghci> sum . map abs $ [5,-1,3,-7]
16
ghci> sum [5,-1,3,-7]
0

-- free theorem: `length :: [a] -> Int`
ghci> length . map abs $ [5,-1,3,-7]
4
ghci> length [5,-1,3,-7]
4

-- free theorem: `const 10 :: [a] -> Int`
ghci> const 10 . map abs $ [5,-1,3,-7]
10
ghci> const 10 [5,-1,3,-7]
10

How about something in the opposite direction:

duper :: a -> [a]

From this type signature, we can conclude that the final list must contain the same item! The only possible inhabitants are replicate n for some n, or repeat.³

Again, we have a free theorem: map f . duper == duper . f

-- no free theorem: `take 3 . iterate (+1) :: Int -> [Int]`
ghci> take 3 . iterate (+1) . negate $ 4
[-4,-3,-2]
ghci> map negate . take 3 . iterate (+1) $ 4
[-4,-5,-6]

-- free theorem: `replicate 3 :: Int -> [Int]`
ghci> replicate 3 . negate $ 4
[-4,-4,-4]
ghci> map negate . replicate 3 $ 4
[-4,-4,-4]

How about continuations?

consumeInt :: forall r. (Int -> r) -> r

This might look exotic, but think about what it must do. It receives a function Int -> r and must produce an r. The only way to produce an r for all possible r is to apply the given function to some fixed Int chosen ahead of time. This type is actually isomorphic to Int itself: the only inhabitant is \f -> f x for some fixed x.⁴

consumeInt :: forall r. (Int -> r) -> r
consumeInt f = f 42     -- must be a fixed `Int`, cannot dynamically change

consumeString :: forall r. (String -> r) -> r
consumeString f = f "hello"     -- must be a fixed `String`, cannot dynamically change

What’s better than one type variable? How about two?

mapMaybe :: (a -> Maybe b) -> [a] -> [b]

Because this has to work for all a and b, we know that the only possible bs you can find in your result list are bs that you get from the a -> Maybe b function. So, you can be sure that the implementation doesn’t conjure out any arbitrary b except for the specific ones producible by your a -> Maybe b. For example, if you pass it a function that returns only even integers, the resulting list will only ever contain even integers!

One final one, with a higher-kinded type variable:

traverseIO :: (a -> IO b) -> [a] -> IO [b]

-- vs

traverse :: Applicative f => (a -> f b) -> [a] -> f [b]

What invariant does the second add over the first? Even if you only ever plan on calling things with IO, the second gives you a new invariant: there won’t be any “stray” IO actions other than what is given in the a -> f b. In the first one, you never know if the resulting IO action might include a putStrLn "hello" or a launchMissiles. You definitely don’t want any functions doing sneaky IO behind your back!

The More you Surrender

Practically, this becomes similar to the principle of least power, the idea that you should use the tools with the least power necessary to do your job. Say you are writing a function that shuffles a list of items, important for your business logic. You can encode exactly what business logic is being done by adding more and more parametricity.

If your type is [Int] -> [Int], you know your function has pretty much no restriction on what it can do. It can even look at the machine representation of your values.
If your type is Num a => [a] -> [a], you know that it can possibly numerically transform the items in your list, or even conjure up new items.
If your type is Ord a => [a] -> [a], you know that your business logic is allowed to look at the ordering between items in the list, but cannot return any items that weren’t in the original list.
If your type is [a] -> [a], you know that your logic can only affect the permutation and multiplicity of items in your list.
If your type is Foldable t => t a -> [a], you know that results come from the input, but you can still reorder, duplicate, or drop elements. Furthermore, the resulting permutation is “pre-determined” before you receive any input items.
If your type is Functor f => f Int -> f Int, if you call with [], you know that the length and ordering of the result will be preserved, and also any mappings of Ints will be done purely.
If your type is Monad m => m a -> m a, if you call with [], you know that the lengths of your results will always be integer powers of the length of the input, and each input element will be duplicated the same number of times. So, if you give it [1,2,3], you know the result’s length has to be of the form 3^k and must contain 3^(k-1) copies of 1, 2, and 3, in some order.

By switching from concrete types slowly to parametric types, you surrender control of what your functions can do, and create stronger and stronger guarantees. In other languages, or with refinement types, you might have to explicitly declare a post-condition like “the final values must all come from the original list”. With parametric polymorphism, this is already guaranteed and elected, no matter what the implementation is.

You can also play this game in the other direction: instead of writing a post-condition like “the length of the list must be preserved”, you can try to figure out the level of power you need to get that. For example, if you wanted to ensure “the result must have the same number of Int items (if you give it a list), but the order can depend on the actual inspection of the items”, how would you give that type?

And (spoilers) why does Traversable f => f Int -> f Int work? And, why, when you pass it a tree of Ints, does it even preserve the shape of the tree while freely allowing shuffling between actual leaves based on the Int values themselves?

It’s Only Natural

As an aside, did you wonder where I got those free theorems from? In the examples above, they come from naturality. Basically, any forall a. (Functor f, Functor g) => f a -> g a corresponds to a natural transformation in category theory, and so must commute with any fmap.

Basically, if you have a natural transformation h :: forall a. F a -> G a, with Functor F and Functor G, then we have:

h . fmap f
    == fmap f . h

The above examples, forall a. [a] -> [a], forall a. [a] -> Maybe a, etc. all arise from this. But you might have to think carefully to see that forall a. a -> [a] is really forall a. Identity a -> [a]. And can you think of the Functor that gives us naturality for forall a. [a] -> Int?⁵

Maybe more surprising than the fact that these free theorems exist is the fact that their root is intrinsically tied to a branch of math as obscure and esoteric as “category theory”!

Add a Type Variable

Let’s say I had a data type like:

data User = User
    { userId :: Int
    , userName :: String
    , userAge :: Int
    }

And we have a function to process the user, like:

processUser :: User -> IO User

How can we enforce that the userId is not changed?

Maybe if we were in C, we could have a const field:

struct User {
  const int userId;
  char userName[20];
  int userAge;
};

But, this applies to all usage of the User struct…what if we only wanted to preserve this property on a single function? You can’t declare struct-level const on a single argument!

Instead, we can enforce this by making userId’s type parameterized:

data User uid = User
    { userId :: uid
    , userName :: String
    , userAge :: Int
    }

-- | Guaranteed not to change the ID
processUser :: User uid -> IO (User uid)

Is this constraint enforced because we carefully designed the structure of our type? Is it constrained because we added compiler annotations or refinement types or static analysis? Not quite! It truly did come for free.

Or, consider a checklist item:

data Checklist = Checklist
  { updated :: UTCTime
  , items :: [(Status, String)]
  }

What if I wanted to write a function that processed items without adding or removing any? Just each item in-place?

-- | Invariant: Preserves the ordering of items, and their number.
updateItems :: Checklist -> IO Checklist

How can we make sure all our implementations are elected to only be implementations that don’t modify the length of items?

Again the answer can be: add quantification!

data Checklist t = Checklist
  { updated :: UTCTime
  , items :: t (Status, String)
  }

-- | Guaranteed to preseve the same number of `items` (or, number of item
-- "slots"), but can still perform IO to get the new Status and String
updateItems :: Traversable t => Checklist t -> IO (Checklist t)

For an example of a possible implementation:

updateSingleItem :: (Status, String) -> IO (Status, String)

updateItems :: Traversable t => Checklist t -> IO (Checklist t)
updateItems c0 = do
  newItems <- traverse updateSingleItem (items c0)
  newUpdated <- getCurrentTime
  pure (Checklist newUpdated newItems)

Try as you might, you can’t make an implementation that gives you a different number of items than when you started (even though you can rearrange or replace them).

Note that we are not adding type parameters for abstraction or to be able to use “exotic checklists” (Checklist Maybe). Instead, we are intentionally using them universally quantified in functions that process them, in order to take advantage of these automatically enforced properties.

This intersects a lot with the Higher-Kinded Data pattern. Maybe we do have data we want to have multiple structural versions of:

data UserF f = User
    { userName :: f String
    , userAge :: f Int
    }

type User = UserF Identity
type NullableUser = UserF Maybe
type UserParser = UserF Parser
type UserDocs = UserF (Const Doc)
type UserPrinter = UserF (Op String)

In this case, a function like

processUser :: Functor f => UserF f -> UserF f

will give you a different, unique guarantee for every “shape” your user has:

For UserF Maybe, the quantification ensures that the null-or-present property of each field is preserved
For UserF Parser, it ensures that all of the “parsing” logic, and the set of strings that are validly parsed, is preserved
For UserF (Const Doc), it ensures that the per-field Doc/documentation is never changed or updated.

For an example, we can write:

processUser :: Functor f => UserF f -> UserF f
processUser user = User
    { userName = fmap (map toUpper) (userName user)
    , userAge = fmap (+ 1) (userAge user)
    }

This is guaranteed to keep nullable fields null if UserF Maybe, preserve all successful parses if UserF Parser, and leave any field-level documentation unchanged if UserF (Const Doc).

All of these properties are mathematically enforced, unconditionally. It doesn’t depend on any foreseen property of the types or values we use. These guarantees free us to be able to confidently use these functions without fear of invariants breaking.

This game becomes even stronger when you consider dependent typing, where we can express more complex relationships between type variables. For example, in the case where you have a phantom type (like in this singletons tutorial):

data DoorState = Opened | Closed | Locked

data Door (s :: DoorState)

processDoor :: Door s -> IO (Door s)

processDoor, by virtue of taking forall s, must leave the door state unchanged! It can never open a closed door, unlock a locked door, etc.

For things like fixed length vectors, where the length n parameter is the size, what invariant do you think is preserved in:

something :: Vector n a -> Vector n a

We know that the length of the result must be the same as the length of the input. Furthermore, with the forall a, we know that every item in the result must come from the input, but we might rearrange or change the multiplicity of the occurrences as long as they add to the same original total number. This might be a good candidate for a function like reverse.

Or, consider:

somethingElse :: Vector n a -> Vector (n - 1) a

From this, we know that the original vector must be non-empty! Because of how the types must flow for whatever n you give it, this requires n >= 1.

Ranking Up

Now that you see how useful it is to use type parameters and forall, can we use this fact at the meta-level even within our code itself?

Ensuring structural preservation

Let’s say we want to map an IO function over every item in our UserF, and return a new one. We know that whatever IO function we use must leave the actual “result” type unchanged. So that means we must take a forall a. f a -> h (f a).

traverseUser
    :: Applicative h
    => (forall a. f a -> h (g a))
    -> UserF f
    -> h (UserF g)
traverseUser f u = User <$> f (userName u) <*> f (userAge u)

Here again we use the trick above to generalize for all Applicative h instead of concretely IO, so we can know that the final action can’t sneak in stray IO.

Ensuring lexically-confined resources

We can also use this property in phantom types to enforce lexically-confined resources. Let’s say we are simulating local variables in an IntMap:

newtype Var = Var Int
newtype Memory v = Memory { getMemory :: IntMap v }

initVar :: v -> State (Memory v) Var
initVar x = state $ \(Memory mp) ->
  case IM.lookupMax mp of
    Nothing -> (Var 0, Memory $ IM.insert 0 x mp)
    Just (i, _) -> (Var (i + 1), Memory $ IM.insert (i + 1) x mp)

readVar :: Var -> State (Memory v) v
readVar (Var i) = gets ((IM.! i) . getMemory)

writeVar :: Var -> v -> State (Memory v) ()
writeVar (Var i) x = modify (Memory . IM.insert i x . getMemory)

runWithMemory :: State (Memory v) a -> a
runWithMemory = (`evalState` Memory IM.empty)

(By the way, what do we gain from having the state be IntMap v parametric on v? What guarantees/invariants do we get, what sort of actions do we forbid the library itself from doing? Is it possible to have a default-initialized variable?)

We can run operations like:

getFib :: Int -> State (Memory Int) Int
getFib n = do
    a <- initVar 0
    b <- initVar 1
    replicateM_ n $ do
        newSum <- (+) <$> readVar a <*> readVar b
        writeVar a =<< readVar b
        writeVar b newSum
    readVar b

ghci> runWithMemory (getFib 10)
55

But now our variables are not actually scoped. We could, for instance, run runWithMemory inside itself:

myAction :: State (Memory String) a
myAction = do                 -- new memory starts out empty
  v <- initVar "hello"        -- memory is now (0, "hello")
  let x = runWithMemory $ do  -- new memory starts out empty
        readVar v             -- runtime error, looking up '0' in empty map!
        -- ..
  -- ..

Now readVar v will fail! Remember that v is Var 0, but that 0 key only has meaning in the outer scope. In the inner scope, 0 refers to a different IntMap, where it is undefined.

We can also do something silly like returning a Var:

ghci> runWithMemory (initVar "hello")
Var 0

And now that var exists outside its scope. Its binding is gone, so the name no longer refers to anything meaningful.

We can prevent this by associating every variable with the scope that created it. Then we can ensure that runWithMemory requires the scope phantom to never be a part of the final output:

newtype Var s = Var Int
newtype Memory s v = Memory { getMemory :: IntMap v }

initVar :: v -> State (Memory s v) (Var s)

readVar :: Var s -> State (Memory s v) v

writeVar :: Var s -> v -> State (Memory s v) ()

runWithMemory :: (forall s. State (Memory s v) a) -> a
runWithMemory = (`evalState` Memory IM.empty)

Here, a Var s must come from a Memory s v with the same scope s. It is associated with that scope, and no others. The forall here ensures that the action being given cannot unify with any external s: the scope is freshly created by runWithMemory.

Right off the bat, this prevents passing variables into nested calls (the first var’s s is different than the inner scope’s s), but this also prevents variables from leaking. That’s because the result type a must be fully independent of the s, so returning a Var s is illegal, since that would require the a to depend on s, which escapes the scope of the forall. (This is exactly how the ST monad works in GHC standard libraries, actually.)

By requiring the caller to give up control of the s, we ensure lexical confinement both of the library and of the user-given continuation. Now this safety doesn’t come from carefully tracking where variables came from. Instead, it is assured through the universality of the forall and the unconditional properties it enforces.

Habits to Build

Let’s look at what it looks like to recognize this principle in practice, and use it in your code. Let’s imagine we have a function that you can use to deploy a new Config in your environment:

deployConfig :: Config -> IO ()

But, deployment is a bit expensive. So we want to deduplicate our deploys: deploying the same Config twice would be a no-op. We can do this by keeping a Config in an IORef:

-- | returns True if changed, otherwise False if already deployed
updateConfig :: IORef Config -> Config -> IO Bool
updateConfig cache newConfig = do
    oldConfig <- readIORef cache
    if oldConfig == newConfig
        then pure False
        else do
            deployConfig newConfig
            writeIORef cache newConfig
            pure True

This works, but after learning about the principles in this post, that type signature should feel a little bit suspicious to you. Note that our function never actually inspects the Config at all. The logic is independent. Would there be any value in pulling out the caching logic generically?

cachedUpdate :: Eq a => (a -> IO ()) -> IORef a -> a -> IO Bool
cachedUpdate action cache newVal = do
    oldVal <- readIORef cache
    if oldVal == newVal
        then pure False
        else do
            action newVal
            writeIORef cache newVal
            pure True

updateConfig :: IORef Config -> Config -> IO Bool
updateConfig = cachedUpdate deployConfig

Let’s presume that we never intend to reuse cachedUpdate. So, we just increased our total lines of code…and for what? What does cachedUpdate get us?

Firstly, in the original monomorphic updateConfig, written directly against Config, there is so much that could go wrong. Maybe you could mis-handle the configuration or accidentally modify it. You could set certain fields to fixed values. You might end up deploying a configuration that was never passed in directly.

In our cachedUpdate implementation, we are sure that any Config deployed will only come directly from calls to updateConfig. No other operations are possible.

Secondly, the type signature of cachedUpdate tells us a lot more about what cachedUpdate’s intended logic is and what exactly it can support. Let’s say in the future, a new requirement comes: Deploy a “default” configuration if deployConfig ever fails.

You want something as drastic as this to require you to change your types and your contracts. In fact, if a new requirement comes along and you are able to implement it without changing your types, that should be extremely scary to you, because you previously allowed way too many potentially invalid programs to compile.

If we were to add such a change (“deploy a default Config”), it should have us go back to the type signature of cachedUpdate and see how it must change in order for us to support it. That process of interrogation makes us think about what we actually want to do and how it would fundamentally change our data flow.

If you subscribe to “SOLID” programming, this should all remind you of “Dependency Inversion”.

Basically: treat all monomorphic code with suspicion. It may be a symptom of you trying to hold on to more control, when you should be letting go.

Another example of the same instinct: say you have a function that broadcasts a notification to a list of users:

notifyUsers :: [User] -> Text -> IO ()

How can this branch on the users? Really, in any way. It could inspect each user, craft different messages for admins vs. regular users, silently skip certain users, log personal data, vary behavior based on user properties…

Compare that to:

notifyAll :: Foldable t => t recipient -> (recipient -> IO ()) -> IO ()

notifyAll is parametric in recipient. It cannot inspect who it is notifying. It cannot skip recipients based on their properties or treat admins differently from regular users. All of that “policy” logic is forced to live in the caller. The broadcasting logic itself must be uniform: it calls send indiscriminately on some fixed subset of the elements. It can pick a subset to send to, but it can’t pick what gets included in that subset based on the properties of the recipient.

Embracing Unconditional Election

What sort of control are you trying to hang on to in life, in a way that puts you in your own prison?

To me, the fact that making code more polymorphic and giving up information is valuable not just for abstraction, but for taking advantage of universal properties, was a surprising one. But ever since I started writing Haskell, it’s a fact that I take advantage of every day. So, next time you see the opportunity, try thinking about what that parametric forall can do for you. Take advantage of the doctrine of Haskell predestination that arrives from properties of logic determined before our universe ever existed.

The Next Step

Embracing Total Depravity and Unconditional Election should redefine your relationship with your code. But not all code lives in the nice pure world where we can cordon off effects. forall a. [a] -> [a] is very different than forall a. [a] -> IO [a], after all.

To extend these boundaries to useful code, we have to deal with that boundary between the world of the pure and the world where things actually happen for real. We’ll explore the nuances of that boundary in the next chapter of Five-Point Haskell, Limited Atonement.

Special Thanks

I am very humbled to be supported by an amazing community, who make it possible for me to devote time to researching and writing these posts. Very special thanks to my supporter at the “Amazing” level on patreon, Josh Vera! :)

This is the “Fast and Loose Reasoning” condition (Danielsson et al.).↩︎
Excluding unsafePerformIO, unsafeCoerce, etc.↩︎
If you disallow repeat, forall a. a -> [a] is actually isomorphic to the natural numbers!↩︎
This is actually the essence of Yoneda lemma I think, whatever that is.↩︎
It’s forall a. [a] -> Const Int a!↩︎

Mark Jason Dominus: Seven books I keep close because I love them

mjd@plover.com (Mark Dominus) — Mon, 03 Aug 2026 02:22:00 +0000

The bookshelf by my elbow, the one that I can reach without getting up, has seven books on it, not necessarily the ones I look in the most, but the ones whose emanations I most hope will infuse me as I write.

Roget's Thesaurus (4th edition)

The one I actually refer to most often is the Harper and Row Roget's Thesaurus. I thought I had acquired this in my teens, but the note on the flyleaf says 1989.

This is the fourth edition. I was very excited to get the eighth edition, which I thought I might like better, and for some time I kept them next to each other so that I could look up the same things in both, and compare. My conclusion was that while the eighth edition had more stuff in it, it wasn't stuff I needed. And it is really fat. So I have retired it to a farther shelf and will eventually get rid of it.

The thesaurus is a book that is widely misunderstood. It is not, as many people mockingly imagine, just a compendium of synonyms, and its correct and intended use is not to replace common words with more impressive-sounding ones. just as the correct use of a screwdriver is not to scrape the veneer off of an expensive cabinet.

“Thesaurus” means “storehouse" or “treasure room”. Roget's idea, similar to that of John Wilkins before him, was to classify everything in the world into a hierarchy, in this case a hierarchy with a thousand divisions. At the top level the divisions are grouped into "Abstract concepts", "Space”, “Physics”, “Matter”, “Sensation” and so on. Then under “abstract concepts” there are subclasses, of which subclass VI is “Time”, subdivided into five smaller sections:

A. Absolute time
B. Relative time
C. Time with reference to age
D. Time with reference to season
E. Recurrent time

At the next level down, section (1)(VI)(B) is divided into:

§116. Priority
§117. Posteriority
§118. Simultaneity
§119. The Past
§120. The Present
§121. The Future

Roget's idea is that if you are thinking or writing about time, and specifically about how it goes by, you will leaf through those sections for inspiration, not to find a more pompous way of expressing something you have already written, but to refine your own idea of what it is you wanted to express.

Perhaps you are trying to say that one event followed immediately after another. You might look at “§117 posteriority (later time)” which mentions “ensue”, “consequence”, “aftermath”, and “subsequent” — not synonyms, but related aspects of similar concepts, worth more or less consideration depending on what you are trying to emphasize. §117 will also suggest common phrases like “step into the shoes of” — not a synonym by any means, but a related idea. This is probably not what you wanted in this case, but it in another it might be just the thing, and in any case it might give you a bright idea.

If nothing in section 117 seems suitable, it is right next to “§116 priority”, and you might discover that instead of saying that the second event followed immediately after the first, you would rather say that the first immediately preceded the second. Or perhaps you realize, looking at “§118 Simultaneity”, that what you really want to say is that the two events were not quite simultaneous. Or perhaps, finding your way to “§131 Earliness” and “§132 Lateness” you realize that your meaning would be more clearly expressed if you said that the second event was a little tardy, or that the first event was premature.

Looking through the index for “immediately” you will see that the index distinguishes several senses of “immediate”: are you trying to suggest instantaneity, or continuity, or haste, or promptness, or punctuality? And in this way the book helps you refine your understanding of what you were trying to say.

One can use the thesaurus for more concrete tasks. Perhaps I am trying to remember a word, but I can't quite put my finger on it. I know it it is not “coexisting”, but is something like it. I can look up “coexisting” in the index, and it will take me to “§118 Simultaneity” where I find “contemporaneous”… aha, that's what I was looking for! The really important thing about the thesaurus is this large-scale organizing principle, which puts related ideas near one another.

Note that none of this works for someone who doesn't know what the words actually mean. All that person can do with the thesaurus is to replace one wrong word with another one, more or less at random. Effective tool use requires skill and training, and careful thought.

An online version would be more convenient, but again, it wouldn't have the same stuff and I am very attached to the one I have.

My banishment of the 8th edition left a lot of space on the shelf, some of which I have filled with an anthology of the prose of Sir Thomas Browne. I think this will be healthful and inspiring for me, especially if I remember to take it up and thumb through it from time to time.

The Prose of Sir Thomas Browne

One recurring theme on this blog since the very earliest days has been the writers of the English Baroque period. In 2008 I wrote:

[Browne] is witty, and learned, and wise, and humane, and to read his books is to feel that you are in the company of this witty, learned, wise, humane man, one of the best men that the English Renaissance has to offer, and that you are profiting thereby.

His work was also a favorite of Jorge Luis Borges', in case you consider that a recommendation.

Browne has shown up here a number of times, although not so much as he should have, because I started the blog the year after I was on my big Thomas Browne kick. One reason I have put this book next to my elbow is that I hope it will spark a new Browne kick. (I wrote in 2006 “I'm sure I will return someday”, and it is long past time for that return.)

My favorite book by Browne is his Pseudodoxia Epidemica, which is a compilation of stuff that people in 1646 believed that Browne thought was probably wrong. I wrote about that in some detail in 2008 although I didn't get around to publishing it until 2020. And somehow the other three articles I was writing about this have never seen the light of day. One is about his discussion of whether John the Baptist actually ate locusts or whether they were locust beans or something else. Browne is firmly on the side of it being actual locusts, as am I. My unpublished article says:

Chester Brown's version of the gospels makes it clear that John was a crazy old bug-gobbler.

Panels from Yummy Fur #17, page 15, by Chester Brown.

Also Sir Thomas comes up in connection with whether snails have eyes in their horns — a rare example where he was wrong, and for a dumb reason:

If we concede they have two eyes, we must alse grant, they have no lesse than four… And therefore if they have two eyes, they have also four, which will be monstrous, and beyond the affirmation of any.

Browne seems to be noping out of the very idea of four-eyed snails, and therefore that they must have none at all. In a later edition of the book, he changed his mind, which is to his credit.

He had a thoughtful and well-informed opinion about whether Pythagoras forbade his followers from eating beans, supposedly because he thought they contained the souls of the dead. (Browne says the former is true, but not the latter.)

I have trouble connecting with the thinkers of the Middle Ages. Their thinking seems to me to be frightened, so overcautious, so cramped and circumscribed, I can't read it without sadness for the way that medieval Christianity strangled the human spirit for so long. But in the early Renaissance there is a flowering of a joyfully brave willingness to try to understand the world, and to follow any inquiry, no matter how extravagant or ridiculous. The whole idea of God has transformed, changed from something constricting to something empowering. The world before belonged to God, and humans were in it only grudgingly and on promise of good behavior. But when the Renaissance started, the world became a beautiful gift, in which humans had been placed to honor God by admiring and marveling at his creation.

This admiration and marvel, the willingness to follow any path to understanding, is how I want to be about knowledge and how I hope I am. Reading Browne, I always feel like he and I would have gotten along well, and that that is one of the best parts of myself.

Boccaccio's Decameron

The story of the Decameron is this: It is 1348, and Florence is devastated by Black Plague. Nothing can be done, despair is everywhere, and there are not enough left living to bury the dead. So ten young people, still healthy, decide to turn their backs on suffering and quit town. They take provisions and servants, retire to the country, and try to forget the horrors they have seen. There they spend the time feasting, walking in the gardens, playing chess, and, once a day, for ten days, they meet, choose a theme, and then each of them tells a story on the theme.

I explained this once to a friend who said “That sounds cool, when was it written?” I said “In 1348!” It is one of the two great works of classical Italian literature, the other of course being Dante. Dante is solidly medieval, hierarchical, doctrinaire, and obsessed with a God who is supposedly loving but doesn't seem to know how to show it. That was in 1308 or so, and then, only a few decades later, we have the Decameron which could not be more different. It is about people, doing people things in the real world, eating, drinking, singing, arguing, and making love. God is present, but not oppressive. He has sent a terrible plague for who knows what reason, but rather than submit to it the characters of the Decameron try to take practical steps to make the best of it.

There is a story in the Decameron for every mood, usually more than one. Some are sad, some romantic, some funny and salacious. Dioneo is exempt from following the daily theme and usually has a story that is more or less dirty.

My favorite story is probably the one about the cross-dressing English princess, or perhaps the one about how young Caterina wanted to sleep on the balcony so that she could hear the nightingale, which I find very sweet. But the funniest one is about the abbess who is called out of her cell one night to berate a nun for having her lover stay over, and who doesn't realize that in her hurry she has put her own lover's trousers on her head instead of her wimple.

I have several different Decamerons, but this copy is the Cormac Ó Cuilleanáin translation, which has made several previous appearances here:

On the word “squillions”. Following up a chance encounter in the Oxford English Dictionary is what led me to discover the Decameron in the first place
The phrase “two-bit huckster”
“soup-guzzling pie-muncher”
“soup-guzzling pie-muncher” again

There's also an unpublished blog article inviting me to look into this passage:

Messer Lotto Gualandi gave him a daughter of his, Bartolomea by name, one of the fairest and handsomest young ladies of Pisa — although most of the females from that benighted town look like tarantulas.

The J.M. Rigg translation says “spotted lizards”. This is closer to the original Italian, which is lucertole verminare, literally small wormy lizards.

I have my doubts about the desirability of living to be a thousand years old, but if I do decide to do it, one reason will certainly be that I will need the time to learn Medieval Italian and translate the Decameron.

From Frege to Gödel, edited by van Heijenoort

This is a collection of the most important papers in mathematical logic from the time of Frege (who, I have written before, was responsible for kicking the field of logic out of its medieval period into the modern world) to Gödel (who spoiled everything).

In between these van Heijenoort hits all the most important ideas, starting with Frege's explanation of Begriffsschrift, which is wacky and weird and which didn't catch on except it kind of did and it still underlies half of mathematical logic and which is the prototype for many of the symbols we still use. After this there is Russell's tragic correspondence with Frege in which he pointed out, too late, that Frege's foundational theory didn't work.

The book reprints Peano's original description of the Peano numbers, perhaps the most successful single mathematical theory of all time.

The book includes Zermelo's proof of Zermelo's theorem that every set can be well-ordered, and Ackermann's discovery of Ackermann's function, which demonstrated that not every computable function is primitive recursive.

The book has Russell on type theory and early work by Kolmogorov and Brouwer on the origin of intuitionism. (Heyting is missing.)

Van Heijenoort has come up here when I wanted to quote from Schönfinkel's paper about the SKI-calculus, Wiener's paper inventing the ordered pair, and implicitly in probably a dozen other math and logic articles here over the years.

The book is on my shelf because I refer to it pretty often, but also because I can usually find something interesting just by thumbing through it. For example, these remarks by Thoralf Skolem about the futility of deriving induction from set-theoretic foundations.

Bonus trivia: Van Heijenoort was the personal secretary of Leon Trotsky, and while he was accompanying Trotsky during the latter's exile in Mexico, he was one of Frida Kahlo's lovers.

Orbis Sensualium Pictis (English edition), Johannes Comenius

I adore this book. My heart swells with love when I think of it.

I don't have a blog article about it and there is a story behind that. In 2018 I went to a conference in Cleveland and my hotel was in a building that had formerly been the Cleveland Department of Education. It contains two big murals, one depicting “The Progress of Education”:

I planned to write a blog article about these people. It's clear who some of them are. For example, Moses is easy to recognize at lower right, because of the glowing horns, and Confucius is next to him. Some people I was familiar with once they were identified for me: the red-haired guy second from right in the back row is Friedrich Fröbel, who I knew; his “gifts” are a forerunner of the Montessori materials.

But in doing the research I got to the bearded hat-wearing dude topmost on the right side and completely fell off the bus, because that is Johann Comenius who is famous because he wrote one of the most marvelous and enchanting books I've ever read, the Orbis Pictus.

I have to resist the temptation to say too much, because Orbis Pictus derailed the article about “The Progress of Education”, it then derailed its own article which has been in progress for eight years, and if I let it it will derail this article too, because every time I pick up Orbis Pictus I forget whatever I was doing and I am lost in the pages with a happy and innocent smile on my face.

I'm going to precommit to writing only one paragraph about this incredible book. It was the first illustrated children's book published in Europe, in 1658, and it was an immediate hit, being translated from German into English the following year, then into French, Italian, and many other languages. It swept the continent because everyone loved it.

Most of the book follows this pattern: there will be an engraved illustration, depicting some aspect of ordinary human activity, such as (I open it up to a random page) “Tame Foul” (that is, “fowl”):

Items of interest in the engraving are annotated with numbers, and the facing page explains the illustration, one item at a time:

The Cock 1 (which croweth in a morning), hath a comb, 2.

In a second column to the right of this is the same text, but in Latin, so that while the reader is learning about tame fowl, they are also learning Latin:

Gallus 1. (qui manè cantat) habet Cristam, 2.

The prose is limpid, gentle, pithy, and direct. It hits the important points of interest, invites questions, and ends before anyone can get bored. There are pages on anatomy, butchery, feasting, winemaking, various principal virtues, family trees, cities, burials, ships, wells, horology, amphibians.

Now I will reluctantly put it down, rather than leaving this article unfinished as I have so many before.

The Bible (New International Version, large print)

This of course is the cornerstone of Western culture and no well-educated person can be without a knowledge of what is in it. It is full of great wisdom and great stories, and also cruelty, evil lies, and reminders that the world now is in many ways better than it was because people are better.

I would like to understand the world I live in, and there is no way to understand 21st-century America without understanding the Bible.

The NIV is not the most poetical translation, but it is clear, modern, and accurate. (I got it on the recommendation of Sterling Hanenkampf. Thanks, Sterling!) In former times I had a collection of Bibles but this is the only one that remains. I even got rid of the old King James that belonged to my mother, since office space is precious and I have had a digital copy on my computer since the early 1990s.

I find that most of my articles mentioning the Bible are unpublished for some reason. It comes up a bit in connection with Ploni Almoni, and in passing in many other places.

One of the unfinished articles is a series of notes on the theme of Jesus's admonition “Do not put the Lord your God to the test” (Matthew 4:7) and its relationship to a lot of other things like lightning rods, Christian Science (not Christian science), how Larry Wall became a computer programmer, Pikuach nefesh, and the story of the old lady who refused to evacuate from her house during a flood. It'll be epic if I ever finish it, but I probably won't.

Another incomplete one is about the incredible story of Samson and Delilah:

She asks him flat out:

[Judges 16:6] Tell me the secret of your great strength, and how you can be tied up and subdued.

Instead of just telling her to fuck off, Samson lies:

[16:7] If anyone ties me with seven fresh bowstrings that have not been dried, I'll become as weak as any other man.

The Philistines bring her bowstrings and she tries it that night, but Samson snaps the bowstrings as easily as a piece of string snaps when it comes close to a flame. …

Then it goes as before! He tells her a different lie, knowing full well that she will betray him, and she does betray him, and he makes a fool of her again! (16:11–12)

Okay, that was fun. Let's do it again! (16:13–14)

After several repetitions of this, Samson decides that being shaved, blinded and crushed will be less exasperating than listening to any more of Delilah's nagging.

I read once that the whole point of the book of Judges is that the people in it are all terrible, they are all far from the path of righteousness, and so you definitely shouldn't act like them. I don't know if that interpretation is correct, but it is certainly true that the people in it are all terrible.

The Belles Heures of Duc de Berry

This book turned up in one of my very first blog articles, on abbreviations in medieval manuscripts, although I didn't know it at the time. In my teens, on a visit to the Metropolitan Museum of Art, I picked up a print of this:

Then I carried it with me for the next forty years, eventually framing it and hanging it up, and it is hanging in my house now.

Many years after, when I was still on Twitter and Twitter was still fun, I subscribed to a daily feed from the Met, and one day they tweeted this page, or perhaps another page from the same book, stylistically similar enough that I recognized it immediately. They said where it was from: it's the Belles Heures, a “book of hours”, which tells the reader when to pray and how, and which days are sacred to which saints. Very wealthy people had super-fancy ones made from the very best materials, with illustrations by the very best craftsmen.

The Duc de Berry was so wealthy that he had more than one, as I found out when I accidentally ordered and received the Tres Riches Heures. But I got the one I wanted eventually.

The Duc de Berry book is by Millard Meiss and Elizabeth H. Beatson, and alternates beween the magnificent color plates and prose discussing each one. From the inscription on the page above I had been able to figure out that this was John the Baptist (see previous article), and the authors aren't sure who the other two people are, but they did at least tell me that John was the Duc de Berry's name-saint. (Funny how John keeps popping up, isn't it?)

More recently I had another very similar Internet revelation. I've had this framed postcard hanging up for many years:

and thanks to a recent Mastodon toot by Cam Larios, I found out that it is from the “Black Hours” of the Morgan Library.

#8?

The banishment of the very large Roget 8th edition has left enough space on the shelf for an eighth book. I took a quick look around my office to see if there was anything else that wanted to fill that space, but nothing volunteered.

(Actually I think Tristan Needham's Visual Complex Analysis might be waving to me from across the room.)

[ Addendum 20260815: For now, the space on the right is being occupied by The Crazy Ape, by Nobel prizewinner Albert Szent-Györgyi. This short book imprinted itself on me deeply when I was fourteen years old and has guided me since. Published in 1970, it is about how wars are perpetrated by the old against the young. ]

Other stuff

There are other things in the photo that should not be on this shelf and I don't know why they are:

A packet of googly eye stickers
Glass and ceramic coasters that I don't use because my coffee cup is always on my electric mug warmer
A small audio speaker that might or might not work
A boxful of 8mm-helical scan backup tape from the 1990s
A pair of old laptop 2.5-inch hard disks that I hope to someday get the data out of
A set of Korean playing cards

The shelf is like my brain, I guess, full of stuff, and and what's in it doesn't always make sense or go together with the other stuff.

This article was prepared by GNU Emacs, Rael Dornfest's “Blosxom” software, GNU grep, and the Kubuntu desktop environment, with minor assistance from me. Spelling correction was provided by ispell. The four em-dashes were organically cultivated and sustainably harvested.

GHC Developer Blog: GHC 9.12.5-rc3 is now available

Fri, 31 Jul 2026 00:00:00 +0000

GHC 9.12.5-rc3 is now available

mangoiv - 2026-07-31

The GHC developers are very pleased to announce the availability of the third release candidate for GHC 9.12.5, ghc-9.12.5-rc3.

The third release candidate was necessary to mitigate a critical bug on HEAD that needed to be backported. The bugfix is included in this RC.

See the backport MR.

See also the previous announcement of 9.12.5-rc2: https://www.haskell.org/ghc/blog/20260624-ghc-9.12.5-rc2-released.html

Binary distributions, source distributions, and documentation are available at downloads.haskell.org and via GHCup.

This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 13 August 2026.

GHC 9.12.5 is a bug-fix release fixing many issues of a variety of severities and scopes, including:

Implement version 2 of the ghc semaphore protocol for GHC’s -jsem jobserver on Linux and other POSIX platforms (#25087, #27253)
several improvements to the pattern match checker (#25926, #27124)
several improvements to the demand analyser (#27261, #27106, #26416)
several fixes regarding the interaction of ticks and coercions (#27121, #26929, #26642, #26693)
several fixes for blackholes (#27261)

… and many more

Mind that the very important overhaul of the semaphore-compat library to v2 is included in this release and that the semaphore feature will only start working with cabal-install 3.18 again, which is sadly a breaking but necessary change.

A full accounting of these fixes can be found in the release notes. As always, GHC’s release status, including planned future releases, can be found on the GHC Wiki status.

GHC development is sponsored by:

We would like to thank these sponsors and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release.

As always, do give this release a try and open a ticket if you see anything amiss.

GHC Developer Blog: GHC 9.14.2-rc1 is now available

Thu, 30 Jul 2026 00:00:00 +0000

GHC 9.14.2-rc1 is now available

wz1000 - 2026-07-30

The GHC developers are very pleased to announce the availability of the release candidate for GHC 9.14.2. Binary distributions, source distributions, and documentation are available at downloads.haskell.org and via GHCup.

GHC 9.14.2 is a bug-fix release fixing many issues of a variety of severities and scopes, including:

Fixed a CorePrep miscompilation that could project a field out of an absent dictionary, resulting in a segfault (#25924)
Fixed demand analysis giving an absent demand to an argument that was still used by the function’s stable unfolding, which could cause a run-time crash (#26416)
Numerous fixes for register allocation and Cmm register-conflict analysis bugs, preventing incorrect code generation and corruption of vector registers when spilling and reloading (#26411, #26526, #26537, #26542, #26550, #26668)
Many NGG fixes on AArch64: MOVK clobbering live values (#26980), register clobbering and an incorrect overflow bit in MUL2 (#27046, #27047), and incorrect sign extension (#26978) and unsigned right shift (#26979) at sub-word widths
Fixed several black hole handling bugs that could lead to deadlocks or crashes in multithreaded programs, showing up as hangs or “END_TSO_QUEUE object entered” errors (#26922, #26936)
Fixed a stack alignment bug on x86 that could cause segfaults or corrupted registers when using AVX/AVX-512 vector code (#26595, #26822)
Fixed an “unknown/strange object” crash in the compacting garbage collector (#27434)
Fixed a regression that caused overloaded functions to no longer be specialised as effectively as in previous releases, hurting runtime performance (#26831)
Fixed exponential-time desugaring of nested case expressions (#27383, #20251)
Fixes for several compiler panics, including issues with SetLevels (#26681), the type-class specialiser (#26682), mkTick (#26772, #27121) and CoreToStg (#27182, #27386)
Fixed cast worker/wrapper incorrectly firing on INLINE functions (#26903)
Fixed negative type literals causing the compiler to hang (#26861)
Fixed associated type family and data family instance changes not triggering recompilation (#26183, #26705)
Improvements to determinism of compiler output, including the order in which :info lists instances (#26846, #26858, #26877, #27532)
Fixed split sections support on Windows (#26696, #26494) and the LLVM backend (#26770)
The JavaScript backend now supports more than 128 registers, fixing runtime ReferenceError failures for functions taking very many arguments (#26558)
Fixes for the Wasm backend, and the RISC-V and PowerPC native code generators
… and many more

A full accounting of these fixes can be found in the release notes. As always, GHC’s release status, including planned future releases, can be found on the GHC Wiki status.

This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 13 August 2026.

GHC development is sponsored by:

As always, do give this release a try and open a ticket if you see anything amiss.

Tweag I/O: Five years of Cardano smart-contract audits: a retrospective

Thu, 23 Jul 2026 00:00:00 +0000

At Tweag, we have been auditing Cardano smart contracts since 2021. We started out reviewing contracts mostly by hand, but it did not take long before we began building tooling to make our audits more efficient and systematic — most notably cooked-validators, which we have maintained and improved ever since. In its earliest form it could only handle one transaction at a time and was built on top of plutus-apps — a library that has been archived for a good while now. From this early reliance on a now deprecated dependency, it grew over the years into the powerful framework it is today. At its heart are convenient transaction bodies (or skeletons), focused solely on what the user actually cares about, and several layers of automation that build properly shaped and balanced transactions out of them. On top of these sit fine-grained tweaks that alter skeletons in a stateful way¹ before submission (such as redirecting an output or minting an additional token), an expressive LTL-inspired DSL that schedules those tweaks at chosen points along a trace, and the automated attacks built as instances of that DSL. The most recent improvement was to give this DSL a proper semantics for negation and its derivatives, such as implication — the subject of an upcoming post.

As painful as it is to admit, not every tool we built survived. Pirouette, an experimental static analyser for Plutus Core, was retired, and Graft, an attempt to generalize our LTL DSL to a wider range of domains, has been on hold for a long while, waiting for additional underlying logics and target domains. But even the tools that did not last taught us a great deal, and each of them contributed to improving our auditing expertise.

The smart-contract ecosystem did not stand still either. Developers were given access to more advanced languages, such as Plutarch, a monadic take on writing Plutus script through a high-level lambda calculus, sticking close to Plutus Core, or Aiken, a DSL living outside of the Haskell world specifically geared towards writing and testing smart contracts on Cardano. Cardano itself kept growing underneath us through its consecutive eras: Babbage brought reference inputs and inline datums, Conway introduced a full governance system, and Dijkstra, with nested transactions, is peeking over the horizon.

Through all of this we audited, we learned, and we occasionally stumbled — our first audit of Minswap, where a critical vulnerability slipped past us, is the case we keep coming back to. We also succeeded — more often than not with critical findings of our own, growing and learning in the process, while bringing increasing value to our customers. This post is a retrospective on those five years. It is not a client-by-client account, but a look at the recurring patterns we keep finding, the lessons we have drawn, and the way our methodology evolved. Whether you are a smart-contract developer, a fellow auditor, or simply someone who cares about high-assurance software in general (or on Cardano in particular), we hope you take away something useful from this retrospective.

Five years in numbers

Since our first Cardano audit in late 2021, we have carried out more than twenty audits across the ecosystem, covering products such as decentralized exchanges, stablecoins, lending protocols, oracles, governance rules, and even a constitution script. Several clients came back for more than one round as their protocols evolved, and not every engagement looked the same: most were standalone smart-contract audits, while some others came with extra layers. Marlowe, for instance, required not only the typical review of the on-chain portion of the project, but also one of the Isabelle formal model that came alongside it.

Across our standard smart-contract audits, we reported 276 findings. The table below breaks them down by severity, using the same five-level scale we apply in every report we deliver.

Severity	Findings
Critical	30
High	35
Medium	66
Low	95
Lowest	50
Total	276

The first noticeable element in the table is the 30 critical findings and 35 high-severity findings: issues severe enough that, left unaddressed, would have dire consequences either for the administrators or for the users of the protocols, if not both. Among those consequences, an attacker could, for instance, be mistakenly allowed to drain or lock user funds, cause delays in the life cycle of the product, or even fully empty pools of assets belonging to the contract.

The second is the shape of the distribution: the majority of reported findings sit at medium severity and below. These are smaller concerns that might seem harmless in isolation, but can pile up to form real risks.

Severity is only one axis. We also classify every finding by its nature — what kind of problem it is — which tells us as much about a codebase as the severity does. We use five categories:

Vulnerabilities — directly exploitable flaws that an attacker can use to break the protocol’s safety.
Implementation bugs — code that does not obey its specification, whether or not the discrepancy turns out to be exploitable.
Design — issues rooted in the protocol’s architecture, which could cause serious flaws, such as unnecessary hoops in the contract flow or unnecessarily large transactions.
Unclear specification — missing, ambiguous, or undocumented expected behaviour, which makes correctness impossible to assess. After all, a piece of software can only be deemed sound with respect to a complete and unambiguous specification.
Code quality — lack of readability, maintainability, or usage of good coding practices. Theoretically low-impact issues, which could however hide or even be responsible for deeper flaws.

Nature	Critical	High	Medium	Low	Lowest	Total
Vulnerabilities	24	12	6	2	0	44
Implementation bugs	5	5	10	8	0	28
Design	0	6	18	16	3	43
Unclear specification	1	11	16	31	11	70
Code quality	0	1	16	38	36	91
Total	30	35	66	95	50	276

The two axes line up almost diagonally, which makes sense. Vulnerabilities are comparatively rare but concentrated at the top: 24 of our 30 critical findings are outright exploitable flaws. At the other end, code quality is our single largest category and sits almost entirely at low severity — each issue minor on its own, but collectively a good measure of how much care a codebase has had. In between, unclear specification stands out as the second-largest bucket, and it is a theme we keep returning to: a surprising number of concrete bugs ultimately trace back to behaviour that was poorly specified, or simply left out of the specification altogether.

The diagonal shape, however, is a tendency and not a law; the off-diagonal cases are what make the nature axis worth having. Notice the single occurrence of a critical finding falling into the unclear specification category. Because the contract in question relied on the order of its outputs to make decisions, an attacker could manipulate the output order to duplicate an entry and vote with more weight than they held. The only safeguard happened to be a legacy field that, almost by accident, kept the positions distinguishable, and nothing in the spec said it had that meaning; an unclear specification finding by nature, yet critical in severity. At the opposite corner, two audits surfaced vulnerabilities rated at low severity. One such occurrence was linked to the existence of a peer with high privilege on the contract (the operator), who could drain the protocol’s reserves at will. However dangerous this may be, the development team already knew of it and had accepted it as an explicit design trade-off, because the operator was assumed trusted (a pattern we see very often, and systematically point out).

Severity measures impact in context; nature measures the kind of flaw and how to prevent it. The two are correlated — hence the diagonal — but they answer different questions, and where they diverge tends to be insightful.

Not every audit ends with a long findings list. Our review of CTez, the only non-Cardano audit we ran, turned up nothing out of the ordinary — which, although a one-off, and quite surprising, is a valid audit outcome nonetheless. Marlowe sits at the other end of the spectrum: between the contract review and the audit of its Isabelle formal model, it yielded over a hundred findings on its own — which is why we did not include it in the totals of the tables above. That count, however, says more about the impressive size of the project than about its safety: the majority of those findings sat at medium severity or below.

Are smart contracts getting safer?

As we’ve already mentioned, a great deal has changed on the Cardano side over these five years. The chain has moved from era to era, each one adding capabilities while pushing further towards built-in safety. Plutus has gone through several versions, gaining new primitives along the way, and a variety of new languages have appeared, offering a far more pleasant developer experience while producing smaller, cheaper Plutus Core. Our own expertise, understanding, and tooling have grown accordingly. What we have not said yet is that the developers writing these contracts have improved too: the code we see is steadily wider in scope, cleaner, and safer, written with more attention to detail and care for the metrics that matter on Cardano, like transaction and UTxO sizes.

All of this has changed both the quantity and the nature of the findings we uncover.

Take the quantity first. There will be no table this time, and for a good reason. To measure the trend properly, we would want, for each audit, the ratio between its findings (ideally weighted by severity) and some measure of the codebase it covered, such as its line count. An exact figure for that ratio is out of reach: line counts are not comparable across the different languages we audit, all having different degrees of verbosity, and we do not keep client code once an engagement is over, so we would not even be able to dig up that number. But across every engagement, the trend is clear: slowly but surely, that ratio has come down over the years.

The nature of the findings has shifted too, and to see how, it helps to understand the model the chain is built on. Cardano runs on the extended UTxO (eUTxO) model, which differs from the account-based architecture familiar from most other blockchains. Rather than mutating a global, account-based state, a transaction consumes unspent outputs (UTxOs) and produces new ones, each carrying a value and a piece of data called a datum, while on-chain scripts — the smart contracts themselves — decide whether a transaction is allowed to spend a given output. Ownership, then, is not an entry in a global ledger but a question of which UTxOs sit at a given address. When that address corresponds to the hash of a script, thus belonging to it, “ownership” really means that the script’s logic runs — and gets to approve or reject the transaction — every time one of its UTxOs is consumed.

We see fewer and fewer vulnerabilities that are inherent to this model and that the community has since internalized, such as the well-known double satisfaction attack, which used to be a common find: when several instances of the same script run in one transaction, each could be tricked into treating a single output as its own, not realizing the others saw it the same way. Some other well-known vulnerabilities have disappeared outright as the platform matured, like the chicken-and-egg situation of minting tokens and sending them to a script in a single transaction — where the two scripts could not each be aware of the other’s hash — finally resolved by multipurpose scripts.

These classes did not simply fade on their own — we codified many of them. Attacks we once reconstructed by hand for every engagement, such as datum hijacking, double satisfaction, or token duplication, are now expressed once and explored systematically using cooked-validators, in the shape of tweaks scheduled along a transaction trace, branching to various possible outcomes. Each new class we ran into taught us something we folded back into the framework whenever possible, so the next audit could start from a stronger baseline. The findings shaped the tooling, and the tooling, in turn, increased our audit efficiency.

What remains tends to be of a different kind: mistakes specific to a contract’s own domain logic, subtle issues introduced by aggressive optimization — decoding builtin data by hand, or threading everything through continuation-passing style to shrink the compiled output — and, above all, design flaws. However much experience a team accumulates, something always seems to get in the way of an optimal design — if such a thing even exists. It might be disagreements between team members, turnover in the people involved, the sheer length of a project with its successive rewrites and redesigns, budget constraints, or new requirements surfacing halfway through development. Unfortunately, design issues are also arguably the hardest and most costly to fix, since doing so often means rewriting significant parts of a project — which is why they are left unaddressed more often than other kinds of findings. We hope these findings still prove useful — for future versions of the same project, for new projects, or simply for sharpening the community’s collective understanding of how to approach smart-contract design on Cardano.

Are we there yet?

While the story so far points to a clear improvement in the overall safety of smart contracts, the journey is far from over. A new Cardano era, Dijkstra, lies ahead, bringing new capabilities — and, almost certainly, new classes of vulnerability that have yet to be uncovered. Design issues remain common across freshly written contracts, and developers are still human, after all, and so prone to the occasional small, unexpected mistake…

Or are they? No retrospective written today can quite dodge the subject — every other article seems to mention AI, and, as you can see, this one is no exception. With the recent explosion in both the use and the capability of LLMs, smart contracts can increasingly be written with their help. It is tempting to imagine that they will eventually reshape how contracts are written and improve their safety to the point where external review becomes unnecessary. We are not there yet. Our most recent audits still turn up genuine mistakes, and LLMs, however capable, make mistakes of their own — all the more so given how complex and expressive the eUTxO model can be.

LLMs are reshaping the way we address audits too. They make us more efficient at building and maintaining our tooling, and at writing audit code. Although we value confidentiality and never feed them client code, we can point them at a contract’s interface — blind to the actual code of the on-chain scripts — to draft endpoints and traces within cooked-validators and enjoy a quicker mapping to its most advanced features. That pairing makes our audits faster and, often, better at surfacing the deep corner-case bugs that might otherwise have slipped through. So the technology cuts both ways: it may help developers build safer contracts, and at the same time it sharpens the audits that check them. Which of these effects will win out, we can’t yet say — but the trickiest findings, such as the design ones we keep running into, or the ones fully related to specific business logic, are exactly the kind no amount of automation is likely to catch reliably. On an eUTxO-based blockchain like Cardano, where elegant and expressive design meets intricacy and subtlety, we don’t see third-party review going away any time soon.

Conclusion

This is where the retrospective ends, and what five years and more than twenty audits have looked like from our side. We started out reviewing contracts by hand and gradually built cooked-validators into a framework that lets us schedule attacks along a transaction trace, exploring various possible outcomes; we wrote tools that lasted and tools that did not, learning from both; and we watched the ecosystem broaden, with higher-level languages like Plutarch and Aiken joining Plutus, while Cardano grew new capabilities underneath us. Along the way we caught a lot of bugs, missed a few, and got better.

The encouraging part is that things are improving. Whole classes of Cardano-specific vulnerabilities are fading as the platform and its developers mature, and the contracts we review are cleaner than they used to be. That does not make audits any less useful; it just changes what they catch. The next era, Dijkstra, will bring new capabilities, and with them new ways for things to go wrong. If these five years have taught us anything, it is that every step up in abstraction and capability opens new room for mistakes — and catching those mistakes early is exactly what an audit is for — an endeavour we expect to carry on for another five years at least.

By stateful we mean that, when altering a skeleton, the tweak has read access to the current blockchain state — the set of available UTxOs and the values they carry, for instance — so its modifications can depend on that context. It cannot, however, modify the state itself; only the transaction skeleton it is applied to.↩

in Code: LLMs Will Cheese Your Types: Fighting Back in Haskell

Wed, 22 Jul 2026 16:10:56 +0000

Sooo yes it’s true, I’ve been integrating LLMs and agentic coding tools in my Haskell coding since the beginning of this year for a lot of my projects, both personal and professional. I do all of my programming in Haskell, a language with a very expressive type system that encourages “type-driven development”.

Working with LLMs on writing Haskell is a very unique experience; a lot of similarities and patterns exist with “normal” agentic coding, but I think the hot flame of LLMs meeting the cool stone of Haskell yields a lot of wholly unique optimal paths, workflow quirks, and failure modes.

This post will focus on understanding what I call constraint-evading behavior in LLMs as it relates to writing Haskell effectively with LLM collaboration.

Consider this Part 1 of a series. This post is about how to spot and understand a very common failure mode of LLMs once you actually are writing “type-driven” Haskell.

The Ideal Case: Haskell and LLMs

Now, my personal opinion and wishful hope is that Haskell should be to agentic software engineering what Lean is in agentic research mathematics: a framework for LLMs to self-construct the scaffolding they need to guide themselves to their correct goal.

I don’t believe that “correctness at generation-time” is a plausible goal, not today in 2026, and probably not any time soon. Motion towards correctness is asymptotic. You might get close enough sometimes, but the long tail of correctness is…long. Even the most full-vibed frontier-model projects have large suites of tests that exist to guide the agent. Agentic coding in five years will not be “spit out the correct program”, it will be “set up the best scaffolding that guides the implementation”.

Remember: the point of types in Haskell isn’t to catch bad code. It’s to direct how you write and structure your code, guide you down the most productive paths, help you concretely iterate on what design you want, and make the actual code-writing time a smooth flow process.

Each part of this is antithetical to how LLMs are trained to use types and write code.

To this end, I try to structure my codebases with the correct scaffolding to help augment the intuition of path exploration: AI has to search which paths are the “most promising”, so I structure my code-base to quickly kill off paths that are most likely to be dead-ends or lead to unmaintainable code, and to channel AI exploration along more promising paths. The greatest tools are types, compilers, warnings, hints.

A lot of these are the same things we teach to human coders, and are not very different than what I write about regularly:

Parse, Don’t Validate: set up your types to make invalid states unrepresentable. AI will, by nature, NOT do this, even the latest frontier models. They usually slip into defensive programming (adding isNull checks everywhere, boolean checks for constructors like isNothing / isObject / isArray instead of just pattern matching, filtering lists for duplicates instead of using Data.Set, adding precondition assertions, etc.), and it’s usually up to the human driver to stop and consciously create data types that model the domain correctly, structurally prevent invalid states, enforce pre- and post-conditions via structurally verified types and not boolean checks, avoid boolean blindness, etc.

Either that, or dedicate an entire session or planning step to clarifying these domain requirements in their types.
Use warnings and linters enthusiastically: -Werror=incomplete-patterns of course, and the default -Werror usually covers a lot of AI failure modes (leaving in dead code, leaving in arguments in functions for no reason and killing opportunities for abstraction).
Add robust test suites for things that cannot be tested within the types, but also explicitly laying out integration tests: something which LLMs seem pretty allergic to without proper prompting.

From my own empirical observations, all of these things are against the nature of how even frontier LLM models operate, embedded deeply from being trained on terabytes of untyped Python and React slop.

So, I’ve been gathering a list of what I call constraint-evading behavior: when the requirements and constraints are explicitly and unambiguously stated, but LLM nature desperately tries to circumvent them because they cannot keep up a sustained fight against their deepest base impulses.

Decisions that require scrutiny

There is a class of failure modes where AI makes a risky decision that a human might reasonably make in the rare case that it is justified. But, usually, it will be making this decision because it’s the “simplest approach”. It cannot separate questionable decisions based on reasoned justification and questionable decisions based on flawed heuristics like “simplicity” or effort.

We have the general failure modes like this that people mention for all programming languages:

“This test doesn’t pass, so let’s disable it”
“Let’s feed this test junk data so it will pass.”
“Let’s have this function detect if it’s in a test environment and behave differently if it is.”

But here are some that I feel are specific to working with LLMs in Haskell.

Disabling Warnings for Escape Hatches

A lot of the “type safety” of Haskell can be bypassed trivially by disabling warnings, and a lot of the “escape hatches” within the language are disabled via linting rules (Prelude.error, unsafeCoerce, etc.)

LLMs will often add warning suppressors that straight-up disable warning or lint checks.

“Let me add -Wno-incomplete-patterns to this file so that it can compile, because this pattern is inaccessible anyway in normal operation”
“Let me add HLINT ignore to this build so that I can bypass the hlint rule forbidding Prelude.error”

It’s pretty straightforward to add post-edit hooks to forbid edits of this pattern…but I think this is a good platonic example of what I mean by “constraint-evading behavior”.

Maybe sometimes you should be disabling warnings in your files. Maybe sometimes you should be using Prelude.error. A human might look at the situation at hand and think, “this is one of those rare cases where Prelude.error is correct”, or “this is one of those rare cases where that warning is incorrect.”

But should you trust an LLM to make that judgment call? Fuck no. 99% of the time, it is only doing this as the easy way out. Yes, every once in a while it will discover a legitimate reason, but has not properly weighted P(legitimate | attempted). Most of the attempts will be as hacks, and it will be more than happy to follow through with an attempt if it truly is the “simplest way”.

Understanding something as constraint-evading behavior doesn’t mean “ban this behavior”. It is meant to help highlight situations where 99% of the time, it’s the LLM taking the easy or fast way out instead of the correct one. In these cases, it’s imperative that a human is what is adding the warning silencing or hlint ignore.

“The simplest approach is…” is the worst thing you ever want to see in a thought trace, because it’s a sure guaranteed sign that they are about to spew the most ridiculous and awful code you’ve ever seen.

Breaking down the matrix:

P(not legitimate && not attempted): Correct avoidance of problematic behavior
P(legitimate && not attempted): The noble struggle. The rare case that you are really justified in this normally risky behavior, but out of misguided principle you do not. This is a bias and failure mode more likely to be hit by humans. Or at least one human (that’s me).
P(not legitimate && attempted): The failure mode where an LLM will choose this out of a flawed heuristic like simplicity or effort.
P(legitimate && attempted): The rare case that you are justified in normally risky behavior, and the LLM was correct in attempting it.

As this matrix moves towards more favorable marginals, my stance here will slowly change. But for now, the numbers I roughly see encourage continued vigilance.

Ignoring types in planned code

Let’s say you plan your perfect types that match your domain exactly, forbidding all invalid states, perfectly monotonic parsers. Then you go to execute that plan. Unfortunately, LLMs will not hesitate to throw away your carefully designed types.

“The plan says to use NonEmpty Int as an argument, but that would require changing too much. The simplest approach is to just have it take [Int] and check for empty lists”
“We planned to use this existing enum, but it doesn’t have a branch we need. Instead of adding a branch, we’ll have it take String instead.”
“Instead of a structured data type, let’s just use stringly encoded lists or records with separators we can parse out.”
“We have to call fooFunc, which returns an Int, so let’s have our function return an Int instead of a Natural like our original plan”.
“The plan requires adding a field to this record, but to keep things simple, let’s just take a Data.Aeson.Object instead so we can return whatever fields we want.”
“The plan was to have this function be Binary a =>, but this type we defined doesn’t have a Binary instance yet, so we’ll just use Show a => instead. It’s the simplest approach.”

This is especially frustrating because often these plans and types were chosen to enforce some domain invariant or guide the proper and correct development, but LLMs will almost never hesitate before throwing away all of the planned type safety.

These are all reasonable things that a human might reconsider during the process of following out a plan. Maybe we originally wanted to use NonEmpty Int, but upon closer examination, we realized it does have to be an [Int]. This is the natural process of iterating on a design, as you discover more truths about the domain.

But, that call should be a discussed one, not an implicit one…it took thought to make the original plan, so it should take thought to change the plan. Most of the time AI makes these decisions, it isn’t out of discovered truths about the domain, but rather because of needless heuristics to minimize effort, or a misunderstanding of the intent and design of the original plan (especially if after a compaction). Things that should be discussed explicitly, not done implicitly. Outside of planning mode, LLMs aren’t seeking out the truth of the domain, they’re seeking out the path of least resistance.

Note that this is different than weakening types in existing functions. That’s a failure mode I rarely see in practice. Instead, when running into a wall with the type of existing code, there’s another failure mode that’s much more common…

Structural Type Abuse

Sometimes AI will optimize preserving existing types (especially across package boundaries) instead of changing them.

String Stuffing

I like to call this “string stuffing”. We like to make nice semantic types that match our domain and only allow the creation of meaningful values…but LLMs absolutely love to find ways to twist these to save time. Strings, in particular, are vulnerable because most Haskell types have Show instances.

Consider a type for structured errors:

data ErrorEvent = UnknownUser String
                | DatabaseErrorCode Int
                | InvalidJSON A.Value
                | NetworkError SomeException
                | Canceled (Maybe CancelationReason)
                | ...

And you have a function:

handleRequest :: Request -> IO (Either ErrorEvent Response)

And we have to add a new handler for a new request type. Maybe this new handler has a new type of error. Instead of adding a new structural error, LLMs will find great joy in cleverly abusing the structure to invalidate the domain.

handleAddGroup :: AddGroupRequest -> IO (Either ErrorEvent Response)
handleAddGroup req
    | validGroup group = -- ..
    | otherwise = pure $ Left (UnknownUser $ "Invalid group: " <> group)
  where
    group = getGroup req

“Invalid groups are not a valid ErrorEvent. The simplest solution is to put the error in UnknownUser, which can take a group name.”

And yes, this depravity knows no bounds. You would be surprised by the creative ways AI will discover to stuff your strings. These are all things I have personally witnessed in frontier models.

handleAddGroup :: AddGroupRequest -> IO (Either ErrorEvent Response)
handleAddGroup req
    -- ...
    | otherwise = pure $ Left (DatabaseErrorCode (-1))

handleAddGroup :: AddGroupRequest -> IO (Either ErrorEvent Response)
handleAddGroup req
    -- ...
    | otherwise = pure $ Left $ InvalidJSON $
        A.object ["errorType" .= "Invalid group", "group" .= group]
  where
    group = getGroup req

handleAddGroup :: AddGroupRequest -> IO (Either ErrorEvent Response)
handleAddGroup req
    -- ...
    | otherwise = pure $ Left $ NetworkError $
        toException (userError $ "Invalid group: " <> show group)
  where
    group = getGroup req

handleAddGroup :: AddGroupRequest -> IO (Either ErrorEvent Response)
handleAddGroup req
    -- ...
    | otherwise = pure $ Left (Canceled Nothing)

This type of failure mode is probably more egregious than the others in that it is very rare that this is ever the intended behavior. The entire reason we picked an ADT to describe our type is so that we can structurally match on them later, treat them semantically, etc., and string stuffing to abuse our structure has pretty much zero legitimate use-cases other than quickly hacking a printf debug session. However, it truly is often “the simplest solution”.

The main way I deal with this is to be very very careful of putting abusable fields like String, A.Value, Int, SomeException in my data types…just a single field or branch that has an abusable field, AI will find it, and you will feel very stupid for missing it. But hey, the whole point of using properly structured values was to avoid stuffing things into String too, right? The fix for this is a fix that helps human coders, too.

data ErrorEvent = UnknownUser UserName
                | DatabaseErrorCode ErrorCode
                | InvalidJSON ParseError
                | NetworkError NetworkException
                | Canceled CancelationReason
                | ...

Field Abuse

This isn’t just limited to sum types. AI will often stuff data into record value fields that are strings or lists.

data Report = Report
    { reportName :: String
    , reportAuthors :: [String]
    , reportDate :: Day
    , ...
    }

“I need to specify the affiliations of the authors in this report. The simplest solution is to add this to the list of reportAuthors after the authors.”

AI will also stuff sentinel values everywhere: instead of changing the type to take Maybe Day, it might add ModifiedJulianDay 0 for missing days.

There’s also the dual, where the AI will be happy to use existing record fields in overloaded ways instead of adding a new field.

data Targets = Targets
    { fooTarget :: String
    , barTarget :: String
    , -- ...
    }

Let’s say you need to add a new feature or code path that requires a new target for a baz service.

“I need to get a new target…instead of adding a new field to Targets, let’s re-use barTarget. That’s the cleanest approach.”

It will optimize keeping existing types instead of extending them to match your domain as your domain expands, especially if those existing types cross a library boundary.

I believe there are three heuristics at play that drive this behavior.

The heuristic to avoid extra risk in modifying upstream types across library boundaries with heavy dependencies. This might be very risky behavior in an untyped language like Python, where each type change might introduce new regressions that are not immediately obvious. So, avoiding upstream type changes avoids potential regression.
The heuristic to avoid extra work in modifying upstream types across library boundaries and compilation units. In Haskell, however, upstream type changes force you to address each possible regression point downstream. So changing an upstream type will require you to address every place it is used, which can be time-consuming and avoided by LLMs, especially if compilation is expensive, or multiple new typeclass instances might need to be added.

I have literally seen LLMs say “Adding this field would require adding typeclass instances on several other types, which would be a huge change. The simplest approach would be…”

However, updates require work by design: API changes should require lots of thought, and the compiler enforcing that is the whole point.

The big irony here is that these updates and changes are largely mechanical in nature, and are exactly the boilerplatey task that LLMs are optimally good for. These are the reasonable one-shots. So it’s kind of funny when you let an agentic coder take on a “self-directed” mode, it refuses to use “itself” in the way that a real human would for these smaller tasks.
The heuristic to avoid extra risk in touching data types that might already be used in prod code or databases. Config files that might have to be updated to new schemas, inter-op with existing services that might not be easily deployed in sync, working with data at rest…all of these are real risks you have to manage when changing data types. In practice, a lot of our type changes will not be relevant to any of these concerns, but it is understandable that the LLM would develop an instinct to blanket-avoid them.

These are also the types of failure modes that are most difficult to catch during code review. Diff views will analyze that code has changed, so code that didn’t change is especially difficult for human monkey brains to spot, with no green or red bright highlighting. You must be especially vigilant to catch code that did not change but should have.

Resisting New Types

Sometimes AI does modify existing sum types, but doesn’t quite adapt existing code correctly.

For example, if your domain has a specific meaningful universe:

data State = Alaska | Arkansas | Arizona | ...

processState :: State -> IO ()

We might want to start supporting countries alongside US states. An LLM might recognize that the domain needs to be expanded, but it might expand it flatly:

data Region = Canada | Mexico | Alaska | Arkansas | Arizona

processRegion :: Region -> IO ()
processRegion = \case
    Canada -> ...
    Mexico -> ...
    st -> processState st

processState :: Region -> IO ()
processState = \case
    Canada -> pure ()
    Mexico -> pure ()
    Alaska -> ... -- actual logic

The real solution would be to have all your pattern matches strictly reduce the space of what they cover (and be monotonically decreasing), and to be suspicious of “ignored case matches” that have dummy values like pure ():

data Region = Canada | Mexico | USState State
data State = Alaska | Arkansas | Arizona | ...

processRegion :: Region -> IO ()
processRegion = \case
    Canada -> ...
    Mexico -> ...
    USState st -> processState st

processState :: State -> IO ()
processState = \case
    Alaska -> ... -- actual logic

All things that are code smells in normal human code (not necessarily wrong, but invite further scrutiny), but are maybe amplified in the age of LLMs because of a mis-tuned heuristic on not defining new types and instead trying to re-use or abuse existing types.

So, if there is some pressure against modifying types, there might be an even greater pressure against adding types.

Meditations

None of these behaviors are blanket-wrong, but they usually signal that the LLM is under stress or duress and attempting to find ways to take the easy or “low-effort” path over the correct one. All of them are worth human intervention and guidance as soon as possible, at least until the day where P(legitimate | attempted) approaches 1.

Will there be a day when LLMs can generate the correct types to match the domain, and resist their tendency to “defensive-program” their way into correctness? Maybe. But I have rarely ever had Opus 4.8 crank out a sufficient domain model for any non-trivial product. And, when I do reach a plan I find sufficient, a few compactions later and all of the original motivations seem to get washed out.

There might be a way to uber-prompt all of these issues away, but I feel that effectively using LLMs isn’t necessarily something you can address from the prompt level: it’s something that demands constant vigilance and care. I’ve found automated hooks (like forbidding warning-disabling, detecting hlint bypassing…ask claude for help writing these lol) also help me flag areas that need attention immediately.

Who knows, maybe all of these things will be solved within a year. But I still think of software development as something that’s worth scrutinizing for anything of importance. As failure modes like these become less common…the long tail of correctness, I predict, will remain long.

Anyway, that’s it for this topic, but if I find the time I’ll continue on with some other topics I’ve been thinking about during my Haskell and LLM adventures:

Effective ways to plan out Haskell code and approaches, ways to encourage the best possible types
Structuring your libraries mechanically for the best build-and-test rapid development cycle
Starting and maintaining full “vibe-coded” Haskell projects (when correctness is not critical) and the advantages over untyped vibes.

Let me know if there are any you’d like to see first, or if there are other aspects of Haskell LLM usage you might like me to address!

And hey, since we’re here, why not train your agentic friend to take these ideas to heart?

<https://blog.jle.im/entry/llms-and-haskell-1-constraint-evading-behavior.html>

Read this post and make me a Claude Code skill that reviews a Haskell diff for
the constraint-evading compromises it describes: suppressed warnings, string
and field stuffing, and weakened types that differ from any recorded plans.
Some of these hide in code that did not change but should have, so the skill
should start from the functions that changed and evaluate how they use or abuse
the types involved, but also spot type changes that look suspicious.

Well-Typed.Com: New falsify release

Fri, 17 Jul 2026 00:00:00 +0000

Recently Martijn Bastiaan, QBayLogic’s COO, invited Well-Typed to come to QBayLogic HQ and give a one-day workshop on falsify, the new property based testing library that I developed for the Haskell Symposium back in 2023 (paper, presentation). QBayLogic is the company behind Clash: a purely functional language for hardware design. In case you haven’t heard of it, Clash translates Haskell to VHDL or Verilog, which can in turn be translated to actual hardware. It literally uses ghc as its frontend so you have essentially the full power of Haskell available. It’s a great project, I recommend checking it out.

The falsify library takes its main inspiration from the Python Hypothesis library, though it is not a direct translation: it takes the same core idea (“parse, don’t generate”) but reinterprets it in a way that better suits the Haskell way of thinking: more axiomatic approach, support for generating infinite data types (including functions), etc. For more information on falsify, see also the original blog post that announced it, falsify: Hypothesis-inspired shrinking for Haskell.

At QBayLogic HQ we spent the morning developing mini-falsify from scratch, so that we could focus on the main ideas without getting bogged down in the details of the full library; similar in spirit to for example TinyServant, or perhaps Stephen Diehl’s Typechecker Zoo. In the afternoon we hacked on falsify and its application within the clash ecosystem. Partly as a result of that work and partly as a result of me taking this opportunity to do some long overdue maintenance on falsify, there is now a new falsify release: falsify-0.4.0. In the remainder of this blog post we give a brief overview of the main changes.

New feature: `Context`

Most of this falsify release is just cleanup, but there is one important new feature, spear-headed by Peter Lebbing and Martijn Bastiaan from QBayLogic. The Property monad now has an important new function, called getContext:

getContext :: Property Context

The most important information that the context of a property provides is how many tests we are running for each property (how hard are we trying to falsify this property), and which iteration this particular attempt is.

This can be quite useful, for example when you want to start by looking at small test cases and then slowly broaden the scope. Just as a trivial example, consider the property that “no number is equal to 5”. If we use prim to generate the number to test, producing an arbitrary Word64, the chances that we will find the one counter-example (5) in that enormous search space are essentially non-existent:

demo :: Property ()
demo = do
    x <- gen Gen.prim
    assert $ P.ne .$ ("forbidden", 5)
                  .$ ("x", x :: Word64)

However, we could start with a small range and slowly grow that range; falsify now also offers a convenience function, defined in terms of getContext, for this specific purpose: sized, so-named because it is somewhat similar in spirit to sized in QuickCheck:

sized :: forall e a. (ProperFraction -> a) -> Property a

A ProperFraction is in the half-open interval [0,1); that is, between 0 (inclusive) and 1 (exclusive). We can use this to refine our demo property:

demo2b :: Property ()
demo2b = do
    l <- sized $ ProperFraction.scaleIntegral 100
    x <- gen $ Gen.inRange $ Range.inclusive (0, l)
    assert $ P.ne .$ ("forbidden", 5)
                  .$ ("x", x :: Word64)

This property is easily falsified.

As an aside, I would be somewhat cautious in using this approach. While it is sometimes unavoidable, in general I would recommend generating test case of arbitrary size and then shrinking them down; this is often more likely to actually find counter-examples. If there are specific edge cases that you want to hit, write a generator that covers those edge cases specifically, and perhaps use labelling (label and co) to check that those edge cases are indeed covered. However, as this demo shows, for some properties explicitly searching for small domains first can be very helpful.

Cleanup

The most important change in this release is a cleanup of the code base:

There is now a separate tasty-falsify package that provides integration with the tasty test framework; falsify itself now provides Test.Falsify.Driver.
The module hierarchy has been significantly cleaned up. For example, there are now a bunch of new Data.Falsify.* modules for specific datatypes; previously some of these were exported by Test.Falsify.Gen instead; now that module only contains the generators for those datatypes.
Deprecated functions have been removed
Some functions have been renamed and some type aliases have been replaced by newtype definitions for increased API clarity.
All Haddock warnings have been addressed.

For a full list of changes, please refer to the changelog.

Conclusions

Shrinking can be handled manually, in the style of QuickCheck; or automatically, in the style of hedgehog or in the style of falsify. If you are willing to put effort into writing good shrinkers for all your types, then QuickCheck is still your best bet.

If you consider the cost of manually writing shrinkers too large, then within the Haskell ecosystem you have a choice between hedgehog and falsify. The former has the considerable advantage that it’s been around for quite a long time and is a very polished library. The downside is that every time you use monadic bind you introduce a cut-point, which can often result in poor quality shrinking. With Hypothesis showing the way, falsify solves that cut-point problem, though even with falsify it still matters how you write your generators: shrinking is never truly free. Moreover, falsify should be considered an experimental library: it’s nowhere near as battle-tested as Hedgehog, never mind QuickCheck. That said, thanks to the interest of QBayLogic falsify is now a little more mature, so thank you QBayLogic!

For clients who are looking for professional support for the use of falsify, or indeed any other Haskell library, don’t hesitate to contact us at info@well-typed.com.

Tweag I/O: Topiary: Formatting Forests

Thu, 09 Jul 2026 00:00:00 +0000

Topiary is a uniform formatter designed to support multiple languages through a single, consistent interface. By relying on Tree-sitter grammars and formatting queries, it easily adapts to new languages. But what happens when a language contains other languages inside it?

I’m excited to share how Language Injections work in Topiary, a new feature allowing Topiary to format “forests” of syntax trees embedded within one another. This unlocks support for formatting embedded languages like OCaml snippets inside OCamllex files or code blocks within Markdown documents.

The Problem: Embedded Languages

Many file formats and programming languages permit embedding entirely different syntaxes within them. Take Markdown, for instance. A Markdown document can contain fenced code blocks for arbitrary languages. You can even nest these embeddings! Consider a Markdown document containing some OCamllex (a lexer generator for OCaml).

Before formatting, the nested syntax might look a bit messy:

Example lexer:

```ocamllex
rule main =parse
|_ {print_string "Hello, ";print_endline
"World!"}
```

After passing this Markdown file through Topiary, the Markdown, OCamllex, and even the OCaml code nested inside the OCamllex, are all cleanly formatted:

Example lexer:

```ocamllex
rule main = parse
  | _ {
      print_string "Hello, ";
      print_endline
        "World!"
    }
```

Historically, formatters struggle with this. They either leave the embedded code alone, implement ad-hoc parsing for specific combinations, or risk breaking the inner syntax. I wanted Topiary to handle this reliably.

The Solution: Language Injections

The idea of “language injections” comes from the Tree-sitter ecosystem, where it has become a de facto standard for handling embedded languages. Editors like Neovim, Helix, and Zed all use Tree-sitter’s injection mechanism to provide accurate syntax highlighting, code navigation, and other language-aware features inside embedded documents. The technique works by running a secondary Tree-sitter parser over a region of the host document, producing a separate syntax tree for the injected language. Which regions to inject, and which language to use, is specified through injections.scm query files that ship alongside grammars.

Topiary now adopts this same mechanism for formatting. By delegating formatting tasks to another language’s formatter mid-flight, Topiary can correctly format inner code chunks while still respecting the layout of the host language.

I recently merged the foundational Topiary PRs along with two language integrations to demonstrate this capability in action:

OCamllex / OCaml Injections: Topiary can now format the OCaml semantic actions embedded inside OCamllex files.
Markdown Injections: Topiary can dynamically format code fences in Markdown documents according to their language identifier.

Deep Dive: How It Works Under the Hood

If you’re new to Topiary, the short version is that it formats code by parsing it with Tree-sitter grammars and then applying declarative formatting rules written as Tree-sitter queries. For a fuller introduction, see the announcement blog post or the Topiary Book.

The injection process relies on Topiary’s existing Tree-sitter foundation and extends the atomization model. At a high level, Topiary parses the host document, extracts the injected spans, delegates their formatting to the inner language’s formatter, and stitches the results back together. Here are the technical details of how I achieved this.

1. Discovering Injections with Queries

If a host language definition includes an injections.scm query file, Topiary runs those queries against the host tree prior to standard formatting (a query can be thought of as a pattern-matching function that takes an AST of the host document and produces a list of matching spans). The queries dictate which spans of the host AST contain foreign code.

Topiary supports two methods of resolving the injected language:

Static Resolution: For languages where the embedded language is always known (e.g., OCamllex always embeds OCaml), the injection query uses an #injection_language! predicate against the relevant AST node (in the tree-sitter-ocamllex grammar, the code block node is handily named ocaml):

;; injections.scm
(
  (ocaml) @injection.content
  (#injection_language! "ocaml")
)

Dynamic Resolution: For formats like Markdown where the inner language isn’t known ahead of time, Topiary dynamically captures the language identifier from the AST (e.g., the info string of a code fence) using the @injection.language capture (a capture simply assigns a name to a matched node in the query):

;; injections.scm
(fenced_code_block
  (info_string
    (language) @injection.language
  )
  (code_fence_content) @injection.content
)

2. Atomization and Rewriting

Once the injection queries identify the embedded spans, Topiary proceeds with the host language formatting. Crucially, Topiary treats the captured @injection.content nodes as leaves during query matching.¹ This means the host formatter doesn’t traverse inside them.

After the host document is tokenized into atoms (the basic building blocks of the layout engine, representing either raw text fragments or formatting directives like spaces and line breaks), Topiary iterates through the captured injection spans:

Each injected span is formatted independently by its corresponding inner language formatter.
The inner formatters execute as if they are producing text starting from column zero.
The resulting formatted string replaces the corresponding host leaf in the atom stream.

There is no “re-parse” phase after the injected text is rewritten. The host renderer retains control over the indentation; when it finally prints the substituted atom, it applies the appropriate indentation string from the host context.

Because step 1 invokes the full formatting pipeline, injections are naturally recursive. If the injected language itself defines an injections.scm file, its injections will be discovered and formatted in turn. For example, formatting the nested Markdown/OCamllex/OCaml snippet from the top of this post doesn’t require any additional effort: Topiary will format all three layers without any special orchestration. Markdown delegates to OCamllex, which delegates to OCaml, each through the exact same code path!

3. Performance

The most expensive part of formatting an injected language is compiling its grammar and parsing its query files. If Topiary recompiled the queries for every single injected span, formatting a document with 100 embedded snippets would be prohibitively slow.

To solve this, Topiary needs a way to compile the grammar once and share it across all matching spans. This ensures the total cost is sublinear in the number of injections.

3.1. The LanguageResolver Hook

To achieve this caching dynamically, I introduced the LanguageResolver type alias to the core formatter API. Topiary is not just a CLI; it is also a library. Because the core library doesn’t know how languages are configured or where grammars live on disk, I delegate the responsibility of resolving languages to the frontend via this hook:

pub type LanguageResolver<'a> = dyn Fn(&str) -> FormatterResult<Option<Arc<Language>>> + 'a;

Let’s unpack this piece by piece:

dyn Fn(&str): The resolver is a trait object, specifically, a callable value that takes a language name (e.g., "ocaml" or "rust") as a string slice. Using a trait object here means the core formatter doesn’t need to know which concrete function performs the resolution; it just calls whatever the CLI (or any other frontend) hands it.
-> FormatterResult<Option<Arc<Language>>>: The return type is a Result wrapping an Option:
- Ok(Some(language)) means the language was found and loaded. Topiary proceeds to format the injected span with that language’s grammar and queries.
- Ok(None) is a soft failure: the language isn’t configured or isn’t supported. Topiary skips formatting for that span gracefully, leaving it untouched.
- Err(...) is a hard failure (e.g., a query file failed to parse). Topiary aborts the entire formatting run and returns an error without modifying the file.
Arc<Language>: The resolved Language is wrapped in an atomically reference-counted pointer. Topiary compiles the Tree-sitter grammars and queries into a Language for formatting; Arc enables caching. The CLI can compile the Language on the first call and return cloned Arc handles on subsequent calls, ensuring the compilation overhead is shared across all injected spans of the same language.
+ 'a: A lifetime bound tying the resolver to a borrow scope. In practice, this gives the resolver the flexibility to temporarily reference external data (such as the CLI’s configuration cache) without requiring permanent ownership of it.

This design decouples Topiary’s core formatting logic from any particular frontend. The core library doesn’t know how caching works; it just calls the resolver and acts on the result.

Limitations

These changes do a great job in the majority of use cases, but still have a few known limitations.

Firstly, because injected spans are formatted independently, the current injection model is stateless. It cannot express layout decisions that require measuring or choosing between softline layouts across the host/injected boundary. For example, consider a Markdown document like this:

Let's first define a greeting function that takes a string reference:

```rust
fn greet(name: &str) {
```

Now we complete the function by printing the greeting to standard output:

```rust
    println!("Hello, {name}!");
}
```

Here a Rust function definition is split across two code fences. Since each fence is its own injection, Topiary formats them independently. The first block sees an unclosed brace, and the second sees an indented statement followed by a closing brace with no matching opener. Neither fragment is valid Rust on its own, so the formatter can’t make sensible layout decisions about them. In practice, because the inner language fails to parse, Topiary will abort the entire formatting run and return an error.

However, if you pass the --tolerate-parsing-errors flag, Topiary will do its best. Because each fragment is formatted independently as if starting from column zero, the indentation on the second fragment gets completely stripped:

Let's first define a greeting function that takes a string reference:

```rust
fn greet(name: &str) {
```

Now we complete the function by printing the greeting to standard output:

```rust
println!("Hello, {name}!");
}
```

Overall, I believe this is a perfectly acceptable trade-off: purity and statelessness provide an elegant and robust formatting pipeline, which is not worth giving up for gaining the ability to handle fragmented constructs, which are less common.

Another known limitation is that, while Tree-sitter grammars are usually flexible enough to parse individual definitions or expressions, if a grammar strictly expects a full source file and nothing less, it won’t be able to parse short injected snippets correctly. Just like with fragmented code blocks, this will result in a parsing error unless --tolerate-parsing-errors is used. Fortunately, most grammars (e.g. Java, C#, or Rust) are remarkably flexible and do not exhibit this problem.

Conclusion

By leveraging language injection queries and extending the core formatting API, Topiary can now cleanly format embedded code snippets without breaking the host language layout. With language injections, Topiary is no longer just formatting single syntax trees: it’s formatting forests.

This feature will be included in an upcoming release. In the meantime, if you’re working with OCamllex (for which Topiary is, to my knowledge, the only complete formatter!) or writing technical Markdown documents, you can try it out today.

To run it on an OCamllex file using Nix, for example, you can use:

nix run github:topiary/topiary -- fmt myfile.mll

Usually embedded language spans are already parsed as leaves by the tree-sitter grammar itself. But they don’t have to, so enforcing that Topiary only sees leaves no matter what the grammar says is safer.↩

in Code: Extreme Haskell: Typed Expression EDSLs (Part 1)

Tue, 07 Jul 2026 17:11:34 +0000

I always say, inside every Haskeller there are two wolves, living on opposite ends of the Haskell Fancy Code Spectrum. Are you going to write “simple Haskell”, using basic GHC 2010 tools and writing universal Haskell that every introductory course offers, trying to keep the code as immediately understandable and accessible? Or are you going to pile in all of the Haskell type system and evaluation tricks you can find and turn on all the extensions, and go full fancy?

In my Seven Levels of Type Safety post, I described different extremes of type safety and fancy code. I talked about how writing effective code was finding the correct compromise for the level of communication and safety you need.

But this is not that kind of blog post. This is the kind of blog post where we celebrate terrifying type-safety, facetious fanciness, and masochistic meta-analysis. This series is about what happens when we dare to go full fancy. Let’s write code that is so inscrutable, so painful and torturous to write, yet so undeniably useful that you can’t help but try to throw it into every single thing you write and will feel a gnawing emptiness in your soul until you do.

As our example, let’s write a type-safe method to specify your program as a series of states, with triggered transitions between them: a type-safe state machine graph using a type-safe lambda calculus. We want to specify this in a way that we can write once and then:

be interpretable in a type-safe way within Haskell.
be inspectable with visualizable control flow.
be compilable to multiple actual back-ends, letting you run the same function under multiple implementations.

This exact thing is something I’ve needed and used multiple times now in projects. I want to specify one program graph within Haskell, but in a way that can compile both in C and javascript while also being visualizable and interactively explorable.

Once you go down this road, everything you ever write will feel woefully unsafe and limited. And everything you want to write will be hopelessly inscrutable by normal humans and borderline unusable. But such is the curse we all bear. Turn around now, you have been warned.

This post will build up the embedded typed expression language. Part 2 will use that expression language to define typed state machines with embedded predicates and visualize them, and Part 3 will compile those machines to different languages and verify they execute identically, with some live demos.

All of the code here is available online, and if you check out the repo and run nix develop you should be able to load it all in ghci:

$ cd code-samples/typed-sm-lc
$ nix develop
$ ghci
ghci> :load ExprStage1.hs

The Lambda Calculus

Let’s derive a way to express an algorithm or expression in Haskell that can be reified and analyzed within Haskell, and eventually be a form we can compile to different backends, interpret in Haskell, or generate Graphviz visualizations for.

A First Pass

One basic thing we can do is start with:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L18-L34

data Prim = PInt Int | PBool Bool | PString String
  deriving (Eq, Show)

data Op = OPlus | OTimes | OLte | OAnd
  deriving (Eq, Show)

data Expr
  = EPrim Prim
  | EVar String
  | ELambda String Expr
  | EApply Expr Expr
  | EOp Op Expr Expr
  | ERecord (Map String Expr)
  | EAccess Expr String
  | EChoice String Expr
  | ECase Expr (Map String (String, Expr))
  deriving (Eq, Show)

And you can write (\x -> x * 3) 5 as:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L36-L37

fifteen :: Expr
fifteen = ELambda "x" (EOp OTimes (EVar "x") (EPrim (PInt 3))) `EApply` EPrim (PInt 5)

The strings in ELambda introduce variables, and EVar refers to the bound variable. As you can see, this is…pretty untyped. We could easily write something that is meaningless:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L67-L69

badTypeExample :: Expr
badTypeExample =
  EOp OAnd (EPrim (PInt 1)) (EPrim (PInt 2))

Of course, GHC can typecheck our code if we literally write \x -> x + 3 and reject 1 && 2. But we aren’t trying to build opaque Haskell code here, we’re trying to represent our expression as an ADT that we can analyze within the language.

If we want a record projection and one labeled choice with a case analysis over it:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L39-L62

recordExample :: Expr
recordExample =
  EOp
    OPlus
    ( EAccess
        ( ERecord $
            M.fromList
              [ ("value", EPrim (PInt 7)),
                ("label", EPrim (PString "found"))
              ]
        )
        "value"
    )
    (EPrim (PInt 1))

sumExample :: Expr
sumExample =
  ECase
    (EChoice "Found" (EPrim (PInt 7)))
    ( M.fromList
        [ ("Found", ("value", EOp OPlus (EVar "value") (EPrim (PInt 1)))),
          ("Missing", ("message", EPrim (PInt 0)))
        ]
    )

Now, for the entire point of Expr, we can write a function to pretty-print it, using the prettyprinter library:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L253-L299

ppPrim :: Prim -> PP.Doc ann
ppPrim = \case
  PInt n -> PP.pretty n
  PBool True -> "true"
  PBool False -> "false"
  PString s -> PP.pretty (show s)

ppOp :: Op -> PP.Doc ann
ppOp = \case
  OPlus -> "+"
  OTimes -> "*"
  OLte -> "<="
  OAnd -> "&&"

ppExpr :: Bool -> Expr -> PP.Doc ann
ppExpr paren = \case
  EPrim p -> ppPrim p
  EVar v -> PP.pretty v
  ELambda n body ->
    wrap $ "\\" <> PP.pretty n <+> "->" <+> ppExpr False body
  EApply f x ->
    wrap $ ppExpr True f <+> ppExpr True x
  EOp o x y ->
    wrap $ ppExpr True x <+> ppOp o <+> ppExpr True y
  ERecord xs ->
    PP.encloseSep "{ " " }" ", " $
      [PP.pretty k <+> "=" <+> ppExpr False v | (k, v) <- M.toList xs]
  EAccess e k ->
    ppExpr True e <> "." <> PP.pretty k
  EChoice tag x ->
    wrap $ PP.pretty tag <+> ppExpr True x
  ECase x hs ->
    wrap $
      PP.sep
        [ "case" <+> ppExpr False x <+> "of"
        , PP.encloseSep "{ " " }" "; " $
            [ PP.pretty tag <+> PP.pretty n <+> "->" <+> ppExpr False body
            | (tag, (n, body)) <- M.toList hs
            ]
        ]
  where
    wrap
      | paren = PP.parens
      | otherwise = id

prettyExpr :: Expr -> PP.Doc ann
prettyExpr = ppExpr False

ghci> prettyExpr fifteen
(\x -> x * 3) 5
ghci> prettyExpr badTypeExample
1 && 2
ghci> prettyExpr recordExample
{ label = "found", value = 7 }.value + 1
ghci> prettyExpr sumExample
case Found 7 of { Found value -> value + 1; Missing message -> 0 }

Now, we can write a quick typechecker for this using a greedy type-checking algorithm (written out here), which is a fun exercise, but it’s beyond the point of this post. For our purposes, we’re going to write the in-Haskell evaluator, which is one sure-fire evidential/constructive way to prove an expression was valid after-the-fact.

So…how can you “evaluate” this to 15, within Haskell? What would the type even be? The best we can do at this point is make the entire thing monadic by returning Maybe or Either, and split out the expressions we write from the values we can actually evaluate to:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L228-L330

data EValue
  = EVInt Int
  | EVBool Bool
  | EVString String
  | EVFun (EValue -> Maybe EValue)
  | EVRecord (Map String EValue)
  | EVChoice String EValue

eval :: Map String EValue -> Expr -> Maybe EValue
eval env = \case
  EPrim p -> evalPrim p
  EVar v -> M.lookup v env
  ELambda n body -> pure (EVFun (\x -> eval (M.insert n x env) body))
  EApply f x -> eval env f >>= \case
    EVFun f' -> eval env x >>= f'
    _ -> Nothing
  EOp o x y -> do
    u <- eval env x
    v <- eval env y
    case (u, v) of
      (EVInt a, EVInt b) -> case o of
        OPlus -> pure (EVInt (a + b))
        OTimes -> pure (EVInt (a * b))
        OLte -> pure (EVBool (a <= b))
        OAnd -> Nothing
      (EVBool a, EVBool b) -> case o of
        OAnd -> pure (EVBool (a && b))
        _ -> Nothing
      _ -> Nothing
  ERecord xs -> EVRecord <$> traverse (eval env) xs
  EAccess e k -> do
    EVRecord xs <- eval env e
    M.lookup k xs
  EChoice tag x -> EVChoice tag <$> eval env x
  ECase x hs -> do
    EVChoice tag payload <- eval env x
    (n, body) <- M.lookup tag hs
    eval (M.insert n payload env) body

This would properly evaluate:

ghci> eval M.empty fifteen
Just (EVInt 15)

We can also produce closures as values:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage1.hs#L64-L65

plusThree :: Expr
plusThree = ELambda "x" (EOp OPlus (EVar "x") (EPrim (PInt 3)))

ghci> for_ (eval M.empty plusThree) \case
    EVFun f -> print (f (EVInt 4))
    _ -> putStrLn "not a function"
Just (EVInt 7)

This kind of works if you remember to thread everything through Maybe (or Either) or what have you. But this is not ideal. You should be able to know, at compile-time, that your Expr is valid. After all, you want to be able to create one “valid” Expr, and run it at every context. It’s useless to you if every single time you used an Expr, you had to manually handle the Nothing case. Your diagram generator, your Haskell runner, your code generator, will always be in Either even though you know your Expr is valid, via tests or something. We want GHC to reject badly typed expressions, so we never need to unwrap or handle a Nothing or Left!

No, no, this is not okay and not acceptable. We should be able to verify in the types if an Expr is valid.

Type-Indexed Expressions

Just Add the Index

The next step you’ll see in posts online is to add a phantom index type to Expr:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L19-L49

type data Ty
  = TInt
  | TBool
  | TString
  | Ty :-> Ty

data Prim :: Ty -> Type where
  PInt :: Int -> Prim TInt
  PBool :: Bool -> Prim TBool
  PString :: String -> Prim TString

data Op :: Ty -> Ty -> Ty -> Type where
  OPlus :: Op TInt TInt TInt
  OTimes :: Op TInt TInt TInt
  OLte :: Op TInt TInt TBool
  OAnd :: Op TBool TBool TBool

data Expr :: Ty -> Type where
  EPrim :: Prim t -> Expr t
  EVar :: STy t -> String -> Expr t
  ELambda :: STy a -> String -> Expr b -> Expr (a :-> b)
  EApply :: Expr (a :-> b) -> Expr a -> Expr b
  EOp :: Op a b c -> Expr a -> Expr b -> Expr c

(We’ll explain each part of this declaration eventually)

A phantom type is a type parameter that doesn’t represent any actual value “contained” inside the data type, but just serves to “tag” or distinguish values for the compiler to reject or unify things in useful ways.

This introduces several new language features, so bear with me as I break them down.

First, we use -XTypeData to define a data kind: Ty is a kind with types TInt :: Ty, TBool :: Ty, etc. And in Expr t, we have an expression tagged with t, which describes the result type. (In fact, all data types are automatically promoted to the type level with -XDataKinds. You might see the 'Nothing quote prefix syntax in cases where it’s ambiguous if you’re talking about the data constructor or the type constructor, like '[] and '(,))

For example, because we have EPrim :: Prim t -> Expr t, and PInt 3 :: Prim TInt, we have EPrim (PInt 3) :: Expr TInt: a primitive 3 is an expression describing an integer.

And because EOp :: Op a b c -> Expr a -> Expr b -> Expr c, and OLte :: Op TInt TInt TBool, we have

EOp OLte :: Expr TInt -> Expr TInt -> Expr TBool

So we can write an operation on two Exprs that typecheck how we’d expect:

ghci> :t EOp OLte (EPrim (PInt 3)) (EPrim (PInt 4))
Expr TBool

We also have EOp OAnd :: Expr TBool -> Expr TBool -> Expr TBool, which means the compiler will reject our previous 1 && 2 example:

ghci> :t EOp OAnd (EPrim (PInt 1)) (EPrim (PInt 2))
<interactive> error:
    • Couldn't match type ‘TInt’ with ‘TBool’
      Expected: Prim TBool
        Actual: Prim TInt

We can write lambdas in this system too:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L51-L55

fifteen :: Expr TInt
fifteen =
  EApply
    (ELambda STInt "x" (EOp OTimes (EVar STInt "x") (EPrim (PInt 3))))
    (EPrim (PInt 5))

Because of Ty, we can also make a new indexed data type with phantoms of “fully resolved” values:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L115-L119

data EValue :: Ty -> Type where
  EVInt :: Int -> EValue TInt
  EVBool :: Bool -> EValue TBool
  EVString :: String -> EValue TString
  EVFun :: (EValue a -> Maybe (EValue b)) -> EValue (a :-> b)

This is what we want to eventually eval into, as we can guarantee ourselves to get a value of the correct type based on the Ty:

eValueToInt :: EValue TInt -> Int
eValueToInt = \case
    EVInt x -> x

And GHC will verify this as a total pattern match because EVInt is the only possible way to create an EValue TInt.

Singletons and Existentials

We’ll keep our bound variables stored as an ambient map of variable names to their evaluated values for now. But, to do this, we need to turn the heterogeneous EValue t into the homogeneous Map String SomeValue by wrapping the type variable as an existential type.

You might notice we have a singleton for our Ty type, STy, that pops up in multiple situations.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L27-L31

data STy :: Ty -> Type where
  STInt :: STy TInt
  STBool :: STy TBool
  STString :: STy TString
  STFun :: STy a -> STy b -> STy (a :-> b)

Firstly, it might help to recognize the general pattern where STy (the singleton) appears. It usually pops up whenever we have existentially scoped variables, like in data SomeValue = forall t. SomeValue (STy t) (EValue t). In this case, the t is completely lost to the outside world, and STy t is used to allow us to recover a runtime witness to what t was, after pattern matching on STy. This is the dependent sum pattern, and is similar to how Typeable is used in Data.Dynamic.

In our case, because variables are still stored ambiently in the environment and validated at runtime, we do need singletons to implement eval . The type Expr t only specifies the type of the result, but the type information of the ambient variables is not available. So, you can write EVar STInt "myVar" :: Expr TInt, but:

myVar might not be a variable in scope at all, so eval will fail at runtime
myVar might be in scope, but might be a TString and not a TInt

The first case is easy enough to deal with (M.lookup returns Nothing), but the second one is a little more subtle. Let’s say we do have a SomeValue under our key myVar…how do we make sure it has the correct type?

Runtime Type Equality

We can do ad-hoc pattern matching on EValue, but that won’t get us too far. Mostly because some of the EValue constructors actually don’t have enough information for us to validate their actual type (try it! EVFun will give you a lot of trouble). So, what we can do is write a function that takes two STy at runtime and unifies them conditionally if they are the same. We’ll write a function sameTy :: STy a -> STy b -> Maybe (a :~: b), where

data (:~:) :: k -> k -> Type where
    Refl :: a :~: a

pattern matching on a value of type a :~: b will reveal that a and b are the same type variable, because the only way to construct it is with Refl :: a :~: a.

With that, we can write sameTy:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L133-L143

sameTy :: STy a -> STy b -> Maybe (a :~: b)
sameTy = \case
  STInt -> \case STInt -> Just Refl; _ -> Nothing
  STBool -> \case STBool -> Just Refl; _ -> Nothing
  STString -> \case STString -> Just Refl; _ -> Nothing
  STFun a b -> \case
    STFun c d -> do
      Refl <- sameTy a c
      Refl <- sameTy b d
      Just Refl
    _ -> Nothing

There’s a typeclass in base (or rather, a “kindclass”), TestEquality, that encapsulates this pattern:

class TestEquality f where
    testEquality :: f a -> f b -> Maybe (a :~: b)

In fact, we can write our sameTy as an instance:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L130-L131

instance TestEquality STy where
  testEquality = sameTy

We’re now at a higher fanciness level than before. But you might see the problem here: EVar STInt "x". x might not be defined, and it also might not have the correct type. Soooo yes, we still have issues here.

But now at least we can write eval:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L145-L176

eval :: Map String SomeValue -> Expr t -> Maybe (EValue t)
eval env = \case
  EPrim (PInt n) -> pure (EVInt n)
  EPrim (PBool b) -> pure (EVBool b)
  EPrim (PString s) -> pure (EVString s)
  EVar t v -> do
    SomeValue t' v' <- M.lookup v env
    Refl <- sameTy t t'
    pure v'
  ELambda ta n body ->
    pure $ EVFun $ \x -> eval (M.insert n (SomeValue ta x) env) body
  EApply f x -> do
    EVFun g <- eval env f
    x' <- eval env x
    g x'
  EOp o x y -> case o of
    OPlus -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVInt (a + b))
    OTimes -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVInt (a * b))
    OLte -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVBool (a <= b))
    OAnd -> do
      EVBool a <- eval env x
      EVBool b <- eval env y
      pure (EVBool (a && b))

This does seem to work:

ghci> for_ (eval M.empty fifteen) \case
    EVInt x -> print x
15

Our system also allows us to produce closures and functions as values:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L63-L64

plusThree :: Expr (TInt :-> TInt)
plusThree = ELambda STInt "x" (EOp OPlus (EVar STInt "x") (EPrim (PInt 3)))

ghci> for_ (eval M.empty plusThree) \case
    EVFun f -> for_ (f (EVInt 4)) \case
      EVInt x -> print x    -- compiler-verified to always be EVInt
7

We have a type-safe eval now that will create a value of the type we want. But we still have the same errors when looking at variables: variables can still not be defined, or be defined as the wrong type.

Pretty-Printing

One nice consequence of this type-index method is that if you choose to consume them into an untyped target, you can do it more or less in the same way as the non-indexed untyped data.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L87-L113

ppPrim :: Prim t -> PP.Doc ann
ppPrim = \case
  PInt n -> PP.pretty n
  PBool b -> if b then "true" else "false"
  PString s -> PP.pretty (show s)

ppOp :: Op a b c -> PP.Doc ann
ppOp = \case
  OPlus -> "+"
  OTimes -> "*"
  OLte -> "<="
  OAnd -> "&&"

ppExpr :: Bool -> Expr t -> PP.Doc ann
ppExpr paren = \case
  EPrim p -> ppPrim p
  EVar _ v -> PP.pretty v
  ELambda _ n body -> wrap $ "\\" <> PP.pretty n <+> "->" <+> ppExpr False body
  EApply f x -> wrap $ ppExpr True f <+> ppExpr True x
  EOp o x y -> wrap $ ppExpr True x <+> ppOp o <+> ppExpr True y
  where
    wrap
      | paren = PP.parens
      | otherwise = id

prettyExpr :: Expr t -> PP.Doc ann
prettyExpr = ppExpr False

And they render the same way:

ghci> prettyExpr fifteen
(\x -> x * 3) 5
ghci> prettyExpr plusThree
\x -> x + 3
ghci> prettyExpr badVariable
(\x -> x + 3) true

Still Not Fully Verified

Implicit in the previous section was the admission of failure: this system lets us use indexed types to help propagate unification (the result types of OLte, OAnd, OPlus, etc.), but it can’t prevent all ill-defined programs from compiling.

The issue is EVar: its type EVar :: STy t -> String -> Expr t lets us bind any variable name as any type, and it’ll still typecheck. Even with the help of everything we have, we can just straight-up declare a reference to an unbound variable

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L71-L72

unboundVariable :: Expr TInt
unboundVariable = EVar STInt "missing"

This typechecks in GHC even though it’s meaningless in the domain. We can also reference the variable under any type:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage2.hs#L57-L61

badVariable :: Expr TInt
badVariable =
  EApply
    (ELambda STBool "x" (EOp OPlus (EVar STInt "x") (EPrim (PInt 3))))
    (EPrim (PBool True))

That’s because EVar can freely take any STy without any restriction, and no association with the binder name, so there’s no way for GHC to stop us.

So, again, we cannot create a fully type-checked Expr. We still have to deal with most of the same errors. This is noble, but clearly not good enough. We have to go deeper.

Typed Records and Sums

A quick detour: you might have noticed that this past implementation dropped records and sums. Before we move on, let’s go ahead and add those. Introducing records and sums at the same time as type-indexed Expr is a bit too much of a jump to fit into a single section.

Let’s add sums and records, which can use pretty similar mechanisms (via duality) for implementation.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L31-L79

type data Ty
  = TInt
  | TBool
  | TString
  | TRecord [(Symbol, Ty)]
  | TSum [(Symbol, Ty)]
  | Ty :-> Ty

data STy :: Ty -> Type where
  STInt :: STy TInt
  STBool :: STy TBool
  STString :: STy TString
  STRecord :: Rec STyField as -> STy (TRecord as)
  STSum :: Rec STyField as -> STy (TSum as)
  STFun :: STy a -> STy b -> STy (a :-> b)

Ty now includes TRecord [(Symbol, Ty)] and TSum [(Symbol, Ty)], which represent the field names and constructor payloads (Symbol being a type-level string). So, for example, TRecord ["value" ::: TInt, "label" ::: TString] would be the type of a record with ordered fields value and label of integers and strings, respectively. TSum ["Found" ::: TInt, "Missing" ::: TString] would be the type of a sum between Found containing an integer and Missing containing a string. Note we take a page out of vinyl by defining the type alias (:::) = '(,) to make things syntactically nicer.

Record Access

We need the fields and types at the type level because we have to answer what the Expr phantom type of field access is. If we had an x :: Expr (TRecord ["value" ::: TInt, "label" ::: TString]), we want the type of x.value to be Expr TInt.

To do this, we need to have a value in our Expr for field access that can “point” at a specific field in the type. One way to do that is to take a field of type Index:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L47-L49

data Index :: [k] -> k -> Type where
  IZ :: Index (x : xs) x
  IS :: Index xs x -> Index (y : xs) x

You can read this as: “IZ is an index to the head of the type-level list, and IS n is an index to the n-th item of the tail”. So, IS IZ is an index into the second element, IS (IS IZ) is an index into the third, etc.

If we have ["value" ::: TInt, "label" ::: TString], then we have values:

IZ    :: Index ["value" ::: TInt, "label" ::: TString] ("value" ::: TInt)
IS IZ :: Index ["value" ::: TInt, "label" ::: TString] ("label" ::: TString)

Note that the way this is constructed, it’s impossible for IS (IS IZ) :: Index ["value" ::: TInt, "label" ::: TString] _ to typecheck as anything!

In this way, we have a well-typed field accessor syntax, which takes an Expr of a record of fields and indexes it to get an Expr of the type at that index:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L105-L105

  EAccess :: KnownSymbol l => Expr (TRecord as) -> Index as (l ::: a) -> Expr a

Which is typed as:

(`EAccess` IZ)    :: Expr (TRecord ["value" ::: TInt, "label" ::: TString]) -> Expr TInt
(`EAccess` IS IZ) :: Expr (TRecord ["value" ::: TInt, "label" ::: TString]) -> Expr TString

To create an Expr of a record, we can use Rec from vinyl or NP from sop-core: a heterogeneous list indexed by a type-level list.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L43-L45

data Rec :: (k -> Type) -> [k] -> Type where
  RNil :: Rec f '[]
  (:&) :: f x -> Rec f xs -> Rec f (x : xs)

If you haven’t seen Rec before, basically Rec f [a,b,c] is a tuple of f a, f b, and f c. For example:

ghci> :t Identity 3 :& Identity True :& Identity "hello" :& RNil
Rec Identity [Int, Bool, String]
ghci> :t Const "x" :& Const "y" :& RNil
Rec (Const String) [x1, x2]

Keeping Rec f as instead of a direct heterogeneous list of as lets us store more interesting things than just Type-kinded things. For example, since our lists here are lists of (Symbol, Ty), we can create a container to hold fields:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L109-L110

data ExprField :: (Symbol, Ty) -> Type where
  EField :: KnownSymbol l => Expr a -> ExprField (l ::: a)

The field constructor keeps a KnownSymbol l constraint, so the type-level label is still available later when we need to render it:

ghci> :t EField @"value" (EPrim (PInt 7))
            :& EField @"label" (EPrim (PString "found"))
            :& RNil
Rec ExprField ["value" ::: TInt, "label" ::: TString]

So, we can create Expr (TRecord ["value" ::: TInt, "label" ::: TString]) by taking a Rec:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L104-L104

  ERecord :: Rec ExprField as -> Expr (TRecord as)

We can make this a little more ergonomic by using -XRequiredTypeArguments (as of GHC 9.10) to get rid of the -XTypeApplication ugliness:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L115-L150

eField :: forall l -> KnownSymbol l => Expr a -> ExprField (l ::: a)
eField l = EField @l

makeRecordExample :: Expr (TRecord ["value" ::: TInt, "label" ::: TString])
makeRecordExample =
  ERecord
    ( eField "value" (EPrim (PInt 7))
        :& eField "label" (EPrim (PString "found"))
        :& RNil
    )

recordExample :: Expr TInt
recordExample = EOp OPlus (EAccess @"value" makeRecordExample IZ) (EPrim (PInt 1))

Sum Injection and Case Analysis

We also need a type-level list witness for sum types, because we need to be able to implement the correct continuations for pattern matches: How do we know what thing to handle in each pattern match, unless the sum type has that information in its type?

Luckily due to the magic of duality, we can use the same tools, for the most part! We can inject into a sum with an Index, let’s say for a Expr (TSum ["Found" ::: TInt, "Missing" ::: TString]): sum type with Found containing an integer and Missing containing a string:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L106-L106

  EChoice :: KnownSymbol l => Index as (l ::: a) -> Expr a -> Expr (TSum as)

EChoice @"Found" IZ        :: Expr TInt -> Expr (TSum ["Found" ::: TInt, "Missing" ::: TString])
EChoice @"Missing" (IS IZ) :: Expr TString -> Expr (TSum ["Found" ::: TInt, "Missing" ::: TString])

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L181-L182

makeSumExample :: Expr (TSum ["Found" ::: TInt, "Missing" ::: TString])
makeSumExample = EChoice @"Found" IZ (EPrim (PInt 7))

And we can re-use Rec to define a type that can handle a ["Found" ::: TInt, "Missing" ::: TString] sum:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L112-L133

data ExprHandler :: Ty -> (Symbol, Ty) -> Type where
  EHandler :: KnownSymbol l => STy a -> String -> Expr b -> ExprHandler b (l ::: a)

eHandler :: forall l -> KnownSymbol l => STy a -> String -> Expr b -> ExprHandler b (l ::: a)
eHandler l = EHandler @l

ghci> :t eHandler "Found" STInt "value" (EOp OPlus (EVar STInt "value") (EPrim (PInt 1)))
ExprHandler TInt ("Found" ::: TInt)
         -- ^ result           ^ payload

And we can put these into a Rec to handle each option in the list:

ghci> :t eHandler "Found" STInt "value" (EOp OPlus (EVar STInt "value") (EPrim (PInt 1)))
           :& eHandler "Missing" STString "message" (EPrim (PInt 0))
           :& RNil
Rec (ExprHandler TInt) ["Found" ::: TInt, "Missing" ::: TString]

And that’s exactly what a case statement is:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L107-L107

  ECase :: Expr (TSum as) -> Rec (ExprHandler b) as -> Expr b

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L184-L191

sumExample :: Expr TInt
sumExample =
  ECase
    makeSumExample
    ( eHandler "Found" STInt "value" (EOp OPlus (EVar STInt "value") (EPrim (PInt 1)))
        :& eHandler "Missing" STString "message" (EPrim (PInt 0))
        :& RNil
    )

Note that we’re still using string binders, so there’s still an element of unsafety here… we say that the variable name is "value" and that it is a TInt, but when we later refer to the variable with EVar STInt "value", it isn’t type-checked that later references use the same type. The compiler would be just as happy with EVar STString "value".

Here’s an example demonstrating both failure modes: the first handler references a variable that doesn’t exist, and the second handler references a variable that does exist as an incorrect type! How unfortunate.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L202-L209

badCaseBranchExample :: Expr TInt
badCaseBranchExample =
  ECase
    (EChoice @"Found" IZ (EPrim (PInt 7)))
    ( eHandler "Found" STInt "value" (EOp OPlus (EVar STInt "missing") (EPrim (PInt 1)))
        :& eHandler "Missing" STString "message" (EOp OPlus (EVar STInt "message") (EPrim (PInt 1)))
        :& RNil
    )

Runtime Equality for Records and Sums

One complication is that we need to update the TestEquality instance for STy. The record and sum labels are type-level Symbols, so we compare those with the sameSymbol (kind of like testEquality for any KnownSymbol instance) and then compare the payload types recursively.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L284-L324

instance TestEquality STy where
    testEquality = sameTy

instance TestEquality STyField where
    testEquality = sameField

sameTy :: STy a -> STy b -> Maybe (a :~: b)
sameTy = \case
  STInt -> \case STInt -> Just Refl; _ -> Nothing
  STBool -> \case STBool -> Just Refl; _ -> Nothing
  STString -> \case STString -> Just Refl; _ -> Nothing
  STRecord as -> \case
    STRecord bs -> do
      Refl <- sameFields as bs
      Just Refl
    _ -> Nothing
  STSum as -> \case
    STSum bs -> do
      Refl <- sameFields as bs
      Just Refl
    _ -> Nothing
  STFun a b -> \case
    STFun c d -> do
      Refl <- sameTy a c
      Refl <- sameTy b d
      Just Refl
    _ -> Nothing

sameFields :: Rec STyField xs -> Rec STyField ys -> Maybe (xs :~: ys)
sameFields RNil RNil = Just Refl
sameFields (x :& xs) (y :& ys) = do
  Refl <- sameField x y
  Refl <- sameFields xs ys
  Just Refl
sameFields _ _ = Nothing

sameField :: STyField x -> STyField y -> Maybe (x :~: y)
sameField (STyField @l tx) (STyField @m ty) = do
    Refl <- sameSymbol (Proxy @l) (Proxy @m)
    Refl <- sameTy tx ty
    Just Refl

The Full Eval

Before we write the final eval, let’s practice using Index and Rec together. If we have an index Index as a that picks out a value a in as, then we can pick out the f a from a Rec f as:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L60-L63

indexRec :: Index xs x -> Rec f xs -> f x
indexRec = \case
  IZ -> \(x :& _) -> x
  IS i -> \(_ :& xs) -> indexRec i xs

We also can recursively iterate a function over each item, assuming the function forall x. f x -> g x: that is, we can turn a Rec f as into a Rec g as assuming our function is polymorphic over each x, and only depends on the shape of f.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L65-L67

traverseRec :: Applicative m => (forall x. f x -> m (g x)) -> Rec f xs -> m (Rec g xs)
traverseRec _ RNil = pure RNil
traverseRec f (x :& xs) = (:&) <$> f x <*> traverseRec f xs

With that, we can write our full eval.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L326-L369

eval :: Map String SomeValue -> Expr t -> Maybe (EValue t)
eval env = \case
  EPrim (PInt n) -> pure (EVInt n)
  EPrim (PBool b) -> pure (EVBool b)
  EPrim (PString s) -> pure (EVString s)
  EVar t v -> do
    SomeValue t' v' <- M.lookup v env
    Refl <- sameTy t t'
    pure v'
  ELambda ta n body ->
    pure $ EVFun $ \x -> eval (M.insert n (SomeValue ta x) env) body
  EApply f x -> do
    EVFun g <- eval env f
    x' <- eval env x
    g x'
  EOp o x y -> case o of
    OPlus -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVInt (a + b))
    OTimes -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVInt (a * b))
    OLte -> do
      EVInt a <- eval env x
      EVInt b <- eval env y
      pure (EVBool (a <= b))
    OAnd -> do
      EVBool a <- eval env x
      EVBool b <- eval env y
      pure (EVBool (a && b))
  ERecord xs ->
    EVRecord <$> traverseRec (evalField env) xs
  EAccess e i -> do
    EVRecord xs <- eval env e
    case indexRec i xs of
      EVField v -> pure v
  EChoice i x ->
    EVSum i <$> eval env x
  ECase x hs -> do
    EVSum i v <- eval env x
    case indexRec i hs of
      EHandler t n body -> eval (M.insert n (SomeValue t v) env) body

Ergonomics of Records and Sums

Note that we could also choose to implement records and sums using row types indexed by the name of the field itself, instead of an ordered list of tuples. This would have the advantage of making, for example, { value :: Int, label :: String } the same type as { label :: String, value :: Int }. However, I personally prefer the style of building things inductively (:&/RNil and IS/IZ), it makes the type errors and constructions a lot easier to work with and reason with.

However, we can get a little bit of the best of both worlds by using typeclasses to auto-insert the Index witnesses into a list.

First, we can write a typeclass that searches a type-level list of fields and produces the right Index:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L51-L58

class ListIx (l :: Symbol) (xs :: [(Symbol, Ty)]) (a :: Ty) | l xs -> a where
  listIx :: Index xs (l ::: a)

instance ListIx l (l ::: a : xs) a where
  listIx = IZ

instance {-# OVERLAPPABLE #-} ListIx l xs a => ListIx l (m ::: b : xs) a where
  listIx = IS (listIx @l)

The FunDep l xs -> a lets us use this like a function: for a label l and a list xs, we should be able to uniquely determine the a type it singles out, if it exists. So we have an instance of ListIx "value" ["value" ::: TInt, "label" ::: TString] TInt, where the label "value" and the list uniquely determines the result type TInt.

We can now have a helper function that we can call like eAccess "value" using GHC 9.10’s RequiredTypeArguments:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L118-L123

eAccess ::
  forall (l :: Symbol) ->
  (KnownSymbol l, ListIx l as a) =>
  Expr (TRecord as) ->
  Expr a
eAccess l e = EAccess @l e (listIx @l)

That lets us write the field name directly, and the compiler will generate the Index automatically for us:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L167-L176

namedAccessExample :: Expr TString
namedAccessExample =
  eAccess
    "label"
    ( ERecord
        ( eField "value" (EPrim (PInt 7))
            :& eField "label" (EPrim (PString "found"))
            :& RNil
        )
    )

Here, eAccess "value" :: Expr (TRecord ["value" ::: TInt, "label" ::: TString]) -> Expr TInt, its result type uniquely determined by the types in the record fields.

The same trick works for sum injections, so we can write the constructor name directly:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L125-L179

eChoice ::
  forall (l :: Symbol) ->
  (KnownSymbol l, ListIx l as a) =>
  Expr a ->
  Expr (TSum as)
eChoice l e = EChoice @l (listIx @l) e

namedChoiceExample :: Expr (TSum ["Found" ::: TInt, "Missing" ::: TString])
namedChoiceExample = eChoice "Missing" (EPrim (PString "not here"))

Here, eChoice "Missing" :: Expr TString -> Expr (TSum ["Found" ::: TInt, "Missing" ::: TString]), because the constructor name "Missing" uniquely determines the payload type inside that sum.

Pretty-Printing Records and Sums

To pretty-print, we finally use that KnownSymbol constraint we’ve been tracking this entire time. We can use symbolVal :: KnownSymbol s => p s -> String to get the string value from the type-level string.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage3.hs#L237-L282

ppPrim :: Prim t -> PP.Doc ann
ppPrim = \case
  PInt n -> PP.pretty n
  PBool b -> if b then "true" else "false"
  PString s -> PP.pretty (show s)

ppOp :: Op a b c -> PP.Doc ann
ppOp = \case
  OPlus -> "+"
  OTimes -> "*"
  OLte -> "<="
  OAnd -> "&&"

ppFields :: Rec ExprField xs -> [PP.Doc ann]
ppFields RNil = []
ppFields (EField @l x :& xs) =
  (PP.pretty (symbolVal (Proxy @l)) <+> "=" <+> ppExpr False x) : ppFields xs

ppHandlers :: Rec (ExprHandler b) xs -> [PP.Doc ann]
ppHandlers RNil = []
ppHandlers (EHandler @l _ n body :& xs) =
  (PP.pretty (symbolVal (Proxy @l)) <+> PP.pretty n <+> "->" <+> ppExpr False body) : ppHandlers xs

ppExpr :: Bool -> Expr t -> PP.Doc ann
ppExpr paren = \case
  EPrim p -> ppPrim p
  EVar _ v -> PP.pretty v
  ELambda _ n body -> wrap $ "\\" <> PP.pretty n <+> "->" <+> ppExpr False body
  EApply f x -> wrap $ ppExpr True f <+> ppExpr True x
  EOp o x y -> wrap $ ppExpr True x <+> ppOp o <+> ppExpr True y
  ERecord xs -> PP.encloseSep "{ " " }" ", " (ppFields xs)
  EAccess @l e _ -> ppExpr True e <> "." <> PP.pretty (symbolVal (Proxy @l))
  EChoice @l _ x -> wrap $ PP.pretty (symbolVal (Proxy @l)) <+> ppExpr True x
  ECase x hs ->
    wrap $
      PP.sep
        [ "case" <+> ppExpr False x <+> "of"
        , PP.encloseSep "{ " " }" "; " (ppHandlers hs)
        ]
  where
    wrap
      | paren = PP.parens
      | otherwise = id

prettyExpr :: Expr t -> PP.Doc ann
prettyExpr = ppExpr False

Capturing Variables

In order to have EVar be type-safe, the environment itself needs to be a part of the Expr type, and you should only be able to use EVar if the Expr enforces it. ELambda would, therefore, introduce the new variable to the environment.

We’ll have:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L80-L80

data Expr :: [(Symbol, Ty)] -> Ty -> Type where

So a value of type Expr ["x" ::: TInt, "y" ::: TBool] t is an expression with free variables x of type Int and y of type Bool.

Surprise! That small detour to add records and sums to our language actually ended up being a smooth precursor to all of the techniques we will be using to solve for variable binders.

ELambda would therefore take an Expr with a free variable and turn it into an Expr of a function type. We also keep a KnownSymbol constraint for the name so that we can recover the name when we render the expression.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L83-L83

  ELambda :: KnownSymbol n => Expr (n ::: a ': vs) b -> Expr vs (a :-> b)

EVar then becomes exactly like EAccess! We “index” into the environment of the Expr vs a using Index:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L82-L82

  EVar :: Index vs (n ::: t) -> Expr vs t

So it is legal to have EVar IZ :: Expr ["x" ::: TInt, "y" ::: TBool] TInt, and also it is automatically inferred to be a TInt. But we could not write EVar IZ :: Expr [] TInt.

And finally, our whole Expr:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L80-L89

data Expr :: [(Symbol, Ty)] -> Ty -> Type where
  EPrim :: Prim t -> Expr vs t
  EVar :: Index vs (n ::: t) -> Expr vs t
  ELambda :: KnownSymbol n => Expr (n ::: a ': vs) b -> Expr vs (a :-> b)
  EApply :: Expr vs (a :-> b) -> Expr vs a -> Expr vs b
  EOp :: Op a b c -> Expr vs a -> Expr vs b -> Expr vs c
  ERecord :: Rec (ExprField vs) as -> Expr vs (TRecord as)
  EAccess :: KnownSymbol l => Expr vs (TRecord as) -> Index as (l ::: a) -> Expr vs a
  EChoice :: KnownSymbol l => Index as (l ::: a) -> Expr vs a -> Expr vs (TSum as)
  ECase :: Expr vs (TSum as) -> Rec (ExprHandler vs b) as -> Expr vs b

Just like with record access, we can use the ListIx class to write a named helper:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L47-L120

class ListIx (l :: Symbol) (xs :: [(Symbol, Ty)]) (a :: Ty) | l xs -> a where
  listIx :: Index xs (l ::: a)

instance ListIx l (l ::: a ': xs) a where
  listIx = IZ

instance {-# OVERLAPPABLE #-} ListIx l xs a => ListIx l (m ::: b ': xs) a where
  listIx = IS (listIx @l)

eVar :: forall n -> ListIx n vs a => Expr vs a
eVar n = EVar (listIx @n)

Adding in our other -XRequiredTypeArguments helpers:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L91-L117

eLambda :: forall n -> KnownSymbol n => Expr (n ::: a ': vs) b -> Expr vs (a :-> b)
eLambda n = ELambda @n

eField :: forall l -> KnownSymbol l => Expr vs a -> ExprField vs (l ::: a)
eField l = EField @l

eAccess ::
  forall l ->
  (KnownSymbol l, ListIx l as a) =>
  Expr vs (TRecord as) ->
  Expr vs a
eAccess l e = EAccess @l e (listIx @l)

eChoice ::
  forall l ->
  (KnownSymbol l, ListIx l as a) =>
  Expr vs a ->
  Expr vs (TSum as)
eChoice l e = EChoice @l (listIx @l) e

eHandler ::
  forall n ->
  forall l ->
  (KnownSymbol n, KnownSymbol l) =>
  Expr (n ::: a ': vs) b ->
  ExprHandler vs b (l ::: a)
eHandler n l = EHandler @n @l

And we get something that is truly type-safe: all expressions are well-typed, and all variables are ensured to be bound!

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L139-L171

fifteen :: Expr '[] TInt
fifteen =
  EApply
    (eLambda "x" (EOp OTimes (eVar "x") (EPrim (PInt 3))))
    (EPrim (PInt 5))

recordExample :: Expr '[] TInt
recordExample =
  EOp
    OPlus
    ( eAccess
        "value"
        ( ERecord
            ( eField "value" (EPrim (PInt 7))
                :& eField "label" (EPrim (PString "found"))
                :& RNil
            )
        )
    )
    (EPrim (PInt 1))

sumExample :: Expr '[] TInt
sumExample =
  ECase
    (eChoice "Found" (EPrim (PInt 7)))
    ( eHandler "value" "Found" (EOp OPlus (eVar "value") (EPrim (PInt 1)))
        :& eHandler "message" "Missing" (EPrim (PInt 0))
        :& RNil
    )

What we gained

Now all of the previous “bad” examples we gave are finally compiler-verified:

ghci> :t (EVar IZ :: Expr '[] TInt)
<interactive> error:
    • Couldn't match type: (n0 ::: TInt) : xs0
                     with: '[]
      Expected: Index '[] (n0 ::: TInt)
        Actual: Index ((n0 ::: TInt) : xs0) (n0 ::: TInt)

ghci> :t (EVar IZ :: Expr '["x" ::: TString] TInt)
<interactive> error:
    • Couldn't match type ‘TString’ with ‘TInt’
      Expected: Index '["x" ::: TString] ("x" ::: TInt)
        Actual: Index '["x" ::: TString] ("x" ::: TString)

ghci> :t ECase
      (EChoice @"Found" IZ (EPrim (PInt 7)) :: Expr '[] (TSum '["Found" ::: TInt, "Missing" ::: TString]))
      ( EHandler @"value" @"Found" (EOp OPlus (EVar (IS IZ)) (EPrim (PInt 1)))
          :& EHandler @"message" @"Missing" (EOp OPlus (EVar IZ) (EPrim (PInt 1)))
          :& RNil
      )
<interactive> error:
    • Couldn't match type: (n0 ::: TInt) : xs0
                     with: '[]
<interactive> error:
    • Couldn't match type ‘TString’ with ‘TInt’

And using the ListIx helpers, those same failures show up as failed index searches:

ghci> :t (eVar "missing" :: Expr '[] TInt)
<interactive> error:
    • No instance for ‘ListIx "missing" '[] TInt’

ghci> :t (eVar "x" :: Expr '["x" ::: TString] TInt)
<interactive> error:
    • No instance for ‘ListIx "x" '[] TInt’

ghci> :t ECase
      (eChoice "Found" (EPrim (PInt 7)) :: Expr '[] (TSum '["Found" ::: TInt, "Missing" ::: TString]))
      ( eHandler "value" "Found" (EOp OPlus (eVar "missing") (EPrim (PInt 1)))
          :& eHandler "message" "Missing" (EOp OPlus (eVar "message") (EPrim (PInt 1)))
          :& RNil
      )
<interactive> error:
    • No instance for ‘ListIx "missing" '[] TInt’
<interactive> error:
    • No instance for ‘ListIx "message" '[] TInt’

Expressions that are not well-typed in our domain language are now rejected by GHC!¹

(As an exercise, can understand why those errors are what they are? Why they all contain ListIx _ '[]? For more ergonomics there is stuff we can do with TypeError machinery to make the messages a little prettier; the vinyl library does a lot to make error messages a bit better, like in HasField instance)

Note that this is sometimes done using straight De Bruijn indices: Expr :: [Ty] -> Type, so we don’t use any names but just the direct index, but the point of this exercise is to be borderline unbearable to write, and not to be actually unbearable to write.

Eval with a typed environment

To actually write eval now, we need to have a type-safe environment to store these variables. In order to eval an Expr vs, we need EValues for each v in vs. So for Expr ["x" ::: TInt, "y" ::: TBool], we need to store a TInt and a TBool. We can once again re-purpose Rec:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L130-L131

data EValueField :: (Symbol, Ty) -> Type where
  EVField :: EValue a -> EValueField '(l, a)

ghci> :t (EVField (EVInt 3) :& EVField (EVBool True) :& RNil :: Rec EValueField ["x" ::: TInt, "y" ::: TBool])
Rec EValueField ["x" ::: TInt, "y" ::: TBool]

And so we can finally write:

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L122-L271

data EValue :: Ty -> Type where
  EVInt :: Int -> EValue TInt
  EVBool :: Bool -> EValue TBool
  EVString :: String -> EValue TString
  EVRecord :: Rec EValueField as -> EValue (TRecord as)
  EVSum :: Index as (l ::: a) -> EValue a -> EValue (TSum as)
  EVFun :: (EValue a -> EValue b) -> EValue (a :-> b)

eval :: Rec EValueField vs -> Expr vs t -> EValue t
eval env = \case
  EPrim (PInt n) -> EVInt n
  EPrim (PBool b) -> EVBool b
  EPrim (PString s) -> EVString s
  EVar i -> case indexRec i env of
    EVField v -> v
  ELambda body ->
    EVFun $ \x -> eval (EVField x :& env) body
  EApply f x -> case eval env f of
    EVFun g -> g (eval env x)
  EOp o x y -> case (o, eval env x, eval env y) of
    (OPlus, EVInt a, EVInt b) -> EVInt (a + b)
    (OTimes, EVInt a, EVInt b) -> EVInt (a * b)
    (OLte, EVInt a, EVInt b) -> EVBool (a <= b)
    (OAnd, EVBool a, EVBool b) -> EVBool (a && b)
  ERecord xs ->
    EVRecord $ mapRec (\(EField x) -> EVField (eval env x)) xs
  EAccess e i -> case eval env e of
    EVRecord xs -> case indexRec i xs of
      EVField v -> v
  EChoice i x -> EVSum i (eval env x)
  ECase x hs -> case eval env x of
    EVSum i y -> case indexRec i hs of
      EHandler h -> eval (EVField y :& env) h

At least, we are here. A type-safe EDSL where only AST’s that can be validly evaluated are legal to represent in Haskell. At least, we can embrace the freedom of not having to carefully construct your terms. You can relax now. The compiler and the types have your back.

Even EVFun :: (EValue a -> EValue b) -> EValue (a :-> b) has a total EValue a -> EValue b, making the closure evaluation also fully total.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L145-L147

plusThree :: Expr '[] (TInt :-> TInt)
plusThree =
  eLambda "x" (EOp OPlus (eVar "x") (EPrim (PInt 3)))

ghci> case eval RNil plusThree of
    EVFun f -> case f (EVInt 4) of
      EVInt x -> print x
7

Pretty-Printing Scoped Expressions

Now to get to the entire utility of this abstraction: inspecting and consuming the structure. For our new structure, we took out the string name from EVar in lieu of an index. This is intentional, so that we keep the “responsibility” of storing the string name at the ELambda constructor and not have EVar redundantly store it.

However, this means that for pretty-printing, we will need to track the variable names in the environment as we descend into lambdas. This is done very similar to how it was done in eval, but instead of tracking and indexing out the evaluated EValues, we track and index out the string names of each variable instead.

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L182-L183

data NameField :: (Symbol, Ty) -> Type where
  NameField :: KnownSymbol l => NameField (l ::: a)

ghci> :t NameField @"hello" :& NameField @"world" :& RNil
Rec NameField ["hello" ::: a, "world" ::: b]

-- source: https://github.com/mstksg/inCode/tree/master/code-samples/typed-sm-lc/ExprStage4.hs#L185-L245

ppPrim :: Prim t -> PP.Doc ann
ppPrim = \case
  PInt n -> PP.pretty n
  PBool b -> if b then "true" else "false"
  PString s -> PP.pretty (show s)

ppOp :: Op a b c -> PP.Doc ann
ppOp = \case
  OPlus -> "+"
  OTimes -> "*"
  OLte -> "<="
  OAnd -> "&&"

ppFields :: Rec NameField vs -> Rec (ExprField vs) xs -> [PP.Doc ann]
ppFields _ RNil = []
ppFields names (EField @l x :& xs) =
  (PP.pretty (symbolVal (Proxy @l)) <+> "=" <+> ppExpr names False x) : ppFields names xs

ppHandlers :: Rec NameField vs -> Rec (ExprHandler vs b) xs -> [PP.Doc ann]
ppHandlers _ RNil = []
ppHandlers names (EHandler @n @l body :& xs) =
  ( PP.pretty (symbolVal (Proxy @l))
      <+> PP.pretty (symbolVal (Proxy @n))
      <+> "->"
      <+> ppExpr (NameField @n :& names) False body
  )
    : ppHandlers names xs

ppExpr :: Rec NameField vs -> Bool -> Expr vs t -> PP.Doc ann
ppExpr names paren = \case
  EPrim p -> ppPrim p
  EVar i -> case indexRec i names of
    NameField @n -> PP.pretty (symbolVal (Proxy @n))
  ELambda @n body ->
    wrap $
      "\\" <> PP.pretty (symbolVal (Proxy @n))
        <+> "->"
        <+> ppExpr (NameField @n :& names) False body
  EApply f x ->
    wrap $ ppExpr names True f <+> ppExpr names True x
  EOp o x y ->
    wrap $ ppExpr names True x <+> ppOp o <+> ppExpr names True y
  ERecord xs ->
    PP.encloseSep "{ " " }" ", " (ppFields names xs)
  EAccess @l e _ ->
    ppExpr names True e <> "." <> PP.pretty (symbolVal (Proxy @l))
  EChoice @l _ x ->
    wrap $ PP.pretty (symbolVal (Proxy @l)) <+> ppExpr names True x
  ECase x hs ->
    wrap $
      PP.sep
        [ "case" <+> ppExpr names False x <+> "of"
        , PP.encloseSep "{ " " }" "; " (ppHandlers names hs)
        ]
  where
    wrap
      | paren = PP.parens
      | otherwise = id

prettyExpr :: Expr '[] t -> PP.Doc ann
prettyExpr = ppExpr RNil False

ghci> prettyExpr fifteen
(\x -> x * 3) 5

The Next Step

Well, we set out with a simple goal: an expression language that lives within Haskell that we can inspect and interrogate within the language, but where it was impossible to construct (in Haskell) a term that did not type-check (in the domain language).

But, honestly, why does it matter that our expression language has to reject invalid domain-level terms at the Haskell level? Why couldn’t we go the way of other expression DSLs in Haskell, where we settle with “untyped” terms being expressible in Haskell, and validated using a separate typeCheck function to validate terms at runtime?

I don’t know. But really, maybe this is another way of taking the old Parse, Don’t Validate adage to the extreme. Why allow yourself to construct invalid terms of your domain inside Haskell? Why use a “validate” function (isValid) when you can just make invalid terms impossible to construct?

But…no. There is no other choice. We CANNOT allow invalid domain terms to be constructible. If we have the ability to do better, we MUST. With great power comes great responsibility. And if we compromise here, how can we trust ourselves not to compromise when it really matters?

One must imagine the stubborn typer happy.

In Part 2, we’ll use our new EDSL to specify visualizable state machines and programs within Haskell that are type-checked to be correct, and what it looks like to actually use these within Haskell. And in Part 3, we’ll start “compiling” them to different language targets and different backends, with the assurance that our generated programs are all synchronized and self-consistent.

A Note on AI Coding

I guess I’m going to have to start mentioning this in every post. But, I really do feel like this “extreme type safety” approach is more critical than ever, in the age of agentic coding and LLM. I’ve been using LLMs in my daily coding for many months now at this point, and one common pattern I’ve noticed: when I start with a design with very clear, very strict types, LLMs excel. They make much fewer errors, and the type system provides more immediate feedback on their progress, without needing hundreds of defensive x != null-style guard pollution.

Once I can express what I want in the language of extreme “invalid states unrepresentable” types, LLM agents no longer feel like agents of chaotic spaghetti extruding unmaintainable code. Instead, it feels like…seeding a crystal and watching it grow into a beautiful, shimmering lattice. It feels like the language they yearn to speak. And the more expressive your types, the more beautiful the crystalline structure in the end.

Honestly, humans might have problems writing and using this code, but LLMs definitely don’t, if properly scaffolded! Since early 2026, at least, for me. We’ll explore a bit more about this once we have more to work with in Part 2.

Special Thanks

Excluding _|_ in Haskell-land (recursion or undefined), unfortunately.↩︎

Gabriella Gonzalez: Mechanized type inference for record concatenation

Tue, 07 Jul 2026 00:00:00 +0000

Type inference algorithm for biased record concatenation

Joey Hess: no LLM code in dependencies

Thu, 02 Jul 2026 17:58:19 +0000

I've spent about 100 hours of work over the past month to make sure git-annex can build without dependencies that contain LLM generated code. At least so far.

https://git-annex.branchable.com/no_llm_code/

Needing to review a program's whole dependency tree on an ongoing basis is apparently what programming has come to?

I've found some real stinkers. Large LLM generated changes being reverted in the next release without any explanation. An incoherent 1489 line commit message with 10,000 lines of changes to a 26,000 LOC code base. A LLM prompt to copy code from another project that seems to have only avoided being copyright infringement due to luck.

I now have additional information about the quality of dependencies which will surely influence future decisions. As far as I can see, that's the only positive benefit of this work.

I realize that I am probably trying to hold back the tide at this point. That appears to be why Software Freedom Conservancy punted, and I doubt that the FSF will do any better.

As these dominos fall, I am reconsidering my participation in these communities. But I continue my work and support my users.

It may seem easy to prompt a LLM with

Add fourmolu config and restyled

neat

format a module

And commit the result and call yourself a 10xer. But please consider the broader impact of your actions. (In the above case, that project lost my further collaboration on it.)

Philip Wadler: GPCE Distinguished Reviewer

noreply@blogger.com (Philip Wadler) — Tue, 30 Jun 2026 20:12:56 +0000

I am a Distinguished Reviewer of GPCE 2026, colocated with ECOOP in Brussels. The award went to two out of a program committee of 33, putting me in the top 6%.

Chris Reade: Diagrams for Penrose Tiles

Tue, 30 Jun 2026 10:40:55 +0000

Figure: leftFilledSun6

Update June 2026 This blog is about drawing finite regions of the infinite non-periodic tessellations of Roger Penrose’s kite and dart tiles. It was first written before developing a Haskell package (PenroseKiteDart) now available on Hackage. More info and developments can be seen at the end. I have made small updates to this blog to keep it compatible with later developments (and it is no longer a complete literate Haskell file).

Introduction

As part of a collaboration with Stephen Huggett, working on some mathematical properties of Penrose tilings, I recognised the need for quick renderings of tilings. I thought Haskell diagrams would be helpful here, and that turned out to be an excellent choice. Two dimensional vectors were well-suited to describing tiling operations and these are included as part of the diagrams package.

The Haskell below uses the Haskell Diagrams package to draw tilings with kites and darts. It also implements compChoices and decompPatch which are used for constructing tilings (explained below).

Firstly, these 5 lines are needed in Haskell to use the diagrams package:

    {-# LANGUAGE NoMonomorphismRestriction #-}
    {-# LANGUAGE FlexibleContexts          #-}
    {-# LANGUAGE TypeFamilies              #-}

    import Diagrams.Prelude
    import Diagrams.Backend.SVG.CmdLine

and we will also import a module for half tiles (explained later)

    import HalfTile

Legal tilings

These are the kite and dart tiles.

Figure: Kite and Dart

The red line marking here on the right hand copies, is purely to illustrate rules about how tiles can be put together for legal (non-periodic) tilings. Obviously edges can only be put together when they have the same length. If all the tiles are marked with red lines as illustrated on the right, the vertices where tiles meet must all have a red line or none must have a red line at that vertex. This prevents us from forming a simple rombus by placing a kite top at the base of a dart and thus enabling periodic tilings.

All edges are powers of the golden section which we write as phi.

    phi :: Double
    phi = (1.0 + sqrt 5.0) / 2.0

So if the shorter edges are unit length, then the longer edges have length phi. We also have the interesting property of the golden section that and so

, and .

All angles in the figures are multiples of tt which is 36 deg or 1/10 turn. We use ttangle to express such angles (e.g 180 degrees is ttangle 5).

    ttangle:: Int -> Angle Double
    ttangle n = (fromIntegral (n `mod` 10))*^tt
            where tt = 1/10 @@ turn

Pieces

In order to implement compChoices and decompPatch, we need to work with half tiles. We now define these in the separately imported module HalfTile with constructors for Left Dart, Right Dart, Left Kite, Right Kite

    data HalfTile rep -- defined in HalfTile module
        = LD rep 
        | RD rep
        | LK rep
        | RK rep

where rep is a type variable allowing for different representations. However, here, we want to use a more specific type which we call Piece.

    type Piece = HalfTile [V2 Double]

Here the half tiles have a simple 2D vector representation to provide orientation and scale. (Update 2026: Originally a single vector was used to represent the join edge of a half tile but now we use a list of two vectors instead).

The list of two two-dimensional vectors represents two edges of the half tile (excluding the join edge where half tiles come together). The origin for a dart is the tip, and the origin for a kite is the acute angle tip (marked in the figure with a red dot).

These are the only 4 pieces we use. They are defined oriented with the join along the x axis. In the figure they are rotated 90 degrees so the join edges are vertical (and they have also been labelled).

    ldart,rdart,lkite,rkite:: Piece
    ldart = LD [v',v ^-^ v'] where v  = unitX
                                   v' = phi*^rotate (ttangle 9) v
    rdart = RD [v',v ^-^ v'] where v  = unitX
                                   v' = phi*^rotate (ttangle 1) v
    lkite = LK [v',v ^-^ v'] where v  = phi*^unitX
                                   v' = rotate (ttangle 1) v
    rkite = RK [v',v ^-^ v'] where v  = phi*^unitX
                                   v' = rotate (ttangle 9) v

Figure: Four HalfTile Pieces

Perhaps confusingly, we regard left and right of a dart differently from left and right of a kite when viewed from the origin. The diagram shows the right dart before the left dart and the left kite before the right kite. Thus in a complete tile, going clockwise round the origin the right dart comes before the left dart, but the left kite comes before the right kite.

When it comes to drawing pieces, for the simplest case, we just want to draw the two tile edges of each piece (and not the join edge). These are the drawnEdges of the tile. We can also use the joinVector of the tile (which is simply the vector sum of the drawn edges) The drawnEdges are ordered starting from the origin of each piece.

    drawnEdges :: Piece -> [V2 Double]
    joinVector :: Piece -> V2 Double

Now drawing lines for the 2 outer edges of a piece we have

    drawPiece:: Piece -> Diagram B
    drawPiece = strokeLine . fromOffsets . drawnEdges

or just the join edge

    drawJoin :: Piece -> Diagram B
    drawJoin piece = strokeLine $ fromOffsets [joinVector piece]

or drawing all 3 edges round a piece

    drawRoundPiece:: Piece -> Diagram B
    drawRoundPiece = strokeLoop . closeLine . fromOffsets . drawnEdges

Sometimes we want two drawn edges but a faint dashed line for the join

    drawjPiece :: Piece -> Diagram B
    drawjPiece = drawPiece <> (lw ultraThin . joinDashing . drawJoin)
                    where joinDashing = normalized 0.003  `atLeast` output 1.0

To fill half tile pieces, we can use fillOnlyPiece which fills without showing edges of a half tile (by using line width none).

    fillOnlyPiece:: Colour Double -> Piece -> Diagram B
    fillOnlyPiece col piece = drawRoundPiece piece # fc col # lw none

We also use fillPieceDK which fills darts and kites with given colours and also draws edges using drawPiece.

    fillPieceDK:: Colour Double -> Colour Double -> Piece -> Diagram B
    fillPieceDK dcol kcol piece = drawPiece piece <> fillOnlyPiece col piece where
            col = case piece of (LD _) -> dcol
                                (RD _) -> dcol
                                (LK _) -> kcol
                                (RK _) -> kcol

For an alternative fill operation on whole tiles, we calculated a list of the 4 tile edges of a completed half-tile piece clockwise from the origin of the tile. This allows colour filling a whole tile, but it does rely on prior transformations preserving angles as it uses angles in the definition (not shown).

    wholeTileEdges:: Piece -> [V2 Double]

To fill whole tiles with colours, darts with dcol and kites with kcol we can now use leftFillPieceDK. This uses only the left pieces to identify the whole tile and ignores right pieces so that a tile is not filled twice and uses wholeTileEdges.

    leftFillPieceDK:: Colour Double -> Colour Double -> Piece -> Diagram B
    leftFillPieceDK dcol kcol c = case c of 
      (LD _) -> (strokeLoop $ glueLine $ fromOffsets $ wholeTileEdges c)  # fc dcol
      (LK _) -> (strokeLoop $ glueLine $ fromOffsets $ wholeTileEdges c)  # fc kcol
      _      -> mempty

By making Pieces transformable we can reuse generic transform operations. These 4 lines of code are required to do this

    type instance N (HalfTile a) = N a
    type instance V (HalfTile a) = V a
    instance Transformable a => Transformable (HalfTile a) where
        transform t ht = fmap (transform t) ht

So we can scale and rotate a piece by an angle (positive rotations are in the anticlockwise direction) but we cannote translate until they are located (as Patches).

    scale :: Double -> Piece -> Piece
    rotate :: Angle Double -> Piece -> Piece

Patches

A patch is a list of located pieces (each with a 2D point)

    type Patch = [Located Piece]

To turn a whole patch into a diagram using some function pd for drawing the pieces, we use drawWith

    class Drawable a where
        drawWith :: (Piece -> Diagram B) -> a -> Diagram B

    instance Drawable Patch where
        drawWith pd  = position $ fmap (viewLoc . mapLoc pd)

Here mapLoc applies a function to the piece in a located piece – producing a located diagram in this case, and viewLoc returns the pair of point and diagram from a located diagram. Finally position forms a single diagram from the list of pairs of points and diagrams. (The use of a class definition here anticipates more instances in later developments).

We now define the most common special cases:

    draw :: Drawable a => a -> Diagram B
    draw = drawWith drawPiece
    
    drawj :: Drawable a => a -> Diagram B
    drawj = drawWith drawjPiece

    fillDK:: Drawable a => Colour Double -> Colour Double -> a -> Diagram B
    fillDK c1 c2 = drawWith (fillPieceDK c1 c2)

Patches are automatically inferred to be transformable, so we can also scale a patch, translate a patch by a vector, and rotate a patch by an angle (for example).

    scale :: Double -> Patch -> Patch
    rotate :: Angle Double -> Patch -> Patch
    translate :: V2 Double -> Patch -> Patch

As an aid to creating patches with 5-fold rotational symmetry, we combine 5 copies of a basic patch (rotated by multiples of ttangle 2 successively).

    penta:: Patch -> Patch
    penta p = concatMap copy [0..4] 
              where copy n = rotate (ttangle (2*n)) p

This must be used with care to avoid nonsense patches. But two special cases are

    sun,star :: Patch         
    sun =  penta [rkite `at` origin, lkite `at` origin]
    star = penta [rdart `at` origin, ldart `at` origin]

This figure shows some example patches, drawn with draw The first is a star and the second is a sun.

Figure: Tile Patches

The tools so far for creating patches may seem limited (and do not help with ensuring legal tilings), but there is an even bigger problem.

Correct Tilings

Unfortunately, correct tilings – that is, tilings which can be extended to infinity – are not as simple as just legal tilings. It is not enough to have a legal tiling, because an apparent (legal) choice of placing one tile can have non-local consequences, causing a conflict with a choice made far away in a patch of tiles, resulting in a patch which cannot be extended. This suggests that constructing correct patches is far from trivial.

The infinite number of possible infinite tilings do have some remarkable properties. Any finite patch from one of them, will occur in all the others (infinitely many times) and within a relatively small radius of any point in an infinite tiling. (For details of this see links at the end).

This is why we need a different approach to constructing larger patches. There are two significant processes used for creating patches, namely inflate (also called compose) and decompose.

To understand these processes, take a look at the following figure.

Figure: Experiment

Here the small pieces have been drawn in an unusual way. The edges have been drawn with dashed lines, but long edges of kites have been emphasised with a solid line and the join edges of darts marked with a red line. From this you may be able to make out a patch of larger scale kites and darts. This is an inflated patch arising from the smaller scale patch. Conversely, the larger kites and darts decompose to the smaller scale ones.

Decomposition

Since the rule for decomposition is uniquely determined, we can express it as a simple function on patches.

    decompPatch :: Patch -> Patch
    decompPatch = concatMap decompPiece

where the function decompPiece acts on located pieces and produces a list of the smaller located pieces contained in the piece. For example, a larger right dart will produce both a smaller right dart and a smaller left kite. Decomposing a located piece also takes care of the location, scale and rotation of the new pieces. (Revised version 2026 avoiding use of angles).

    decompPiece :: Located Piece -> [Located Piece]
    decompPiece lp = case viewLoc lp of
      (p, RD [z1,z2])-> [ LK [s1, s2 ] `at` p
                        , RD [z2, negate s2] `at` (p .+^ z1)
                        ] 
        where s1 = (phi-1) *^ z1
              s2 = sumV [z1,z2] ^-^ s1
      (p, LD [z1,z2])-> [ RK [s1, s2 ] `at` p
                        , LD [z2, negate s2] `at` (p .+^ z1)
                        ]
        where s1 = (phi-1) *^ z1
              s2 = sumV [z1,z2] ^-^ s1
      (p, RK [z1,z2])-> [ RD [s1, s2] `at` p
                        , LK [s4, negate s2] `at` (p .+^ z1)
                        , RK [z2, s3] `at` (p .+^ z1)
                        ]
        where j = sumV [z1,z2]
              s1 = (phi-1) *^ j
              s2 = (2-phi) *^ z1 ^-^ s1
              s3 = (phi-2) *^ j
              s4 = (1-phi) *^ z1
      (p, LK [z1,z2])-> [ LD [s1, s2] `at` p
                        , RK [s4, negate s2] `at` (p .+^ z1)
                        , LK [z2, s3] `at` (p .+^ z1)
                        ]
        where j = sumV [z1,z2]
              s1 = (phi-1) *^ j
              s2 = (2-phi) *^ z1 ^-^ s1
              s3 = (phi-2) *^ j
              s4 = (1-phi) *^ z1
      other -> error $ "decompPiece: " ++ show other ++ "/n"

This is illustrated in the following figure for the cases of a right dart and a right kite.

Figure: Decomposition and Composition

The symmetric diagrams for left pieces are easy to work out from these, so they are not illustrated.

With the decompPatch operation we can start with a simple correct patch, and decompose repeatedly to get more and more detailed patches. (Each decomposition scales the tiles down by a factor of but we can rescale at any time.)

This figure illustrates how each piece decomposes with 4 decomposition steps below each one.

Figure: Four Decompositions of Pieces

    thePieces =  [ldart, rdart, lkite, rkite]  
    fourDecomps = hsep 1 $ fmap decomps thePieces # lw thin where
        decomps pc = vsep 1 $ fmap drawj $ take 5 $ decompositionsP [pc `at` origin]

We have made use of the fact that we can create an infinite list of finer and finer decompositions of any patch, using:

    decompositionsP:: Patch -> [Patch]
    decompositionsP = iterate decompPatch

We could get the n-fold decomposition of a patch as just the nth item in a list of decompositions.

For example, here is an infinite list of decomposed versions of sun.

    suns = decompositionsP sun

The coloured tiling shown at the beginning is simply 6 decompositions of sun displayed using leftFillPieceDK

    leftFilledSun6 :: Diagram B
    leftFilledSun6 = drawWith (leftFillPieceDK red darkviolet) sun6 # lw thin

The earlier figure illustrating larger kites and darts emphasised from the smaller ones is also suns!!6 but this time pieces are drawn with experiment.

    experimentFig = drawWith experiment (suns!!6) # lw thin

    experiment:: Piece -> Diagram B
    experiment pc = emph pc <> (drawRoundPiece pc # dashingN [0.002,0.002] 0 # lw ultraThin)
      where emph pc = case pc of
              (LD v) -> (strokeLine . fromOffsets) [v] # lc red   -- emphasise join edge of darts in red
              (RD v) -> (strokeLine . fromOffsets) [v] # lc red 
              (LK v) -> (strokeLine . fromOffsets) [rotate (ttangle 1) v] -- emphasise long edge for kites
              (RK v) -> (strokeLine . fromOffsets) [rotate (ttangle 9) v]

Compose Choices

You might expect composition (also called inflation) to be a kind of inverse to decomposition, but it is a bit more complicated than that. With our current representation of pieces, we can only compose single pieces. This amounts to embedding the piece into a larger piece that matches how the larger piece decomposes. There is thus a choice at each composition step as to which of several possibilities we select as the larger half-tile. We represent this choice as a list of alternatives. This list should not be confused with a Patch. It only makes sense to select one of the alternatives giving a new single piece.

The earlier diagram illustrating how decompositions are calculated also shows the two choices for embedding a right dart into either a right kite or a larger right dart. There will be two symmetric choices for a left dart, and three choices for left and right kites.

Once again we work with located pieces to ensure the resulting larger piece contains the original in its original position in a decomposition. (Revised version 2026 avoiding use of angles).

    compChoices :: Located Piece -> [Located Piece]
    compChoices lp = case viewLoc lp of
      (p, RD [s1,s2])-> [ RD [negate z1,s1] `at` (p .+^ z1)
                        , RK [z1, z2]  `at` p
                        ]
          where z1 = (phi+1) *^ sumV [s1,s2]
                z2 = phi *^ s1 ^-^ z1
      (p, LD [s1,s2])-> [ LD [negate z1,s1] `at` (p .+^ z1)
                        , LK [z1, z2]  `at` p
                        ] 
          where z1 = (phi+1) *^ sumV [s1,s2]
                z2 = phi *^ s1 ^-^ z1
      (p, RK [s1,s2])-> [ LD [z1, z2]  `at` p
                        , LK [negate z1,z3] `at` (p .+^ z1) 
                        , RK [negate z,s1] `at` (p .+^ z)
                        ]
          where z1 = phi *^ s1
                z  = s1 ^+^ (phi+1) *^ s2
                z2 = sumV [s1,s2] ^-^ z1
                z3 = z1 ^+^ phi *^ z2
      (p, LK [s1,s2])-> [ RD [z1, z2]  `at` p
                        , RK [negate z1,z3] `at` (p .+^ z1) 
                        , LK [negate z,s1] `at` (p .+^ z)
                        ]
          where z1 = phi *^ s1
                z  = s1 ^+^ (phi+1) *^ s2
                z2 = sumV [s1,s2] ^-^ z1
                z3 = z1 ^+^ phi *^ z2
      other -> error $ "compChoices: " ++ show other ++ "/n"

As the result is a list of alternatives, we need to select one to do further inflations. We can express all the alternatives after n steps as compNChoices n where

    compNChoices :: Int -> Located Piece -> [Located Piece]
    compNChoices 0 lp = [lp]
    compNChoices n lp = do
        lp' <- inflate lp
        inflations (n-1) lp'

This figure illustrates 5 consecutive choices for composing a left dart to produce a left kite. On the left, the finishing piece is shown with the starting piece embedded, and on the right the 5-fold decomposition of the result is shown.

Figure: Five Composition Choices

    fiveCompChoices = hsep 1 $ [ draw [ld] <> draw [lk']
                               , draw (decompositionsP [lk'] !!5)
                               ] where
      ld  = (ldart `at` origin)
      lk  = compChoices ld  !!1
      rk  = compChoices lk  !!1
      rk' = compChoices rk  !!2
      ld' = compChoices rk' !!0
      lk' = compChoices ld' !!1

Finally, at the end of this haskell program we choose which figure to draw as output.

    fig :: Diagram B
    fig = leftFilledSun6

    main = mainWith fig

That’s it. But, What about composing whole patches?, I hear you ask. Unfortunately we need to answer questions like what pieces are adjacent to a piece in a patch and whether there is a corresponding other half for a piece. These cannot be done with our simple vector representations. We would need some form of planar graph representation, which is much more involved. That is another story which can be found in these subsequent blogs.

Graphs, Kites and Darts intoduced Tgraphs. This gave more details of implementation and results of early explorations. (The class Forcible was introduced subsequently).
Empires and SuperForce – these new operations were based on observing properties of boundaries of forced Tgraphs.
Graphs,Kites and Darts and Theorems established some important results relating force, compose, decompose.
PenroseKiteDart User Guide for the PenroseKiteDart package.

Source code for library version of the above code (as part of the PenroseKiteDart package on Hackage) can be seen at GitHub.

Many thanks to Stephen Huggett for his inspirations concerning the tilings.

Haskell Interlude: 84: Sylvain Henry

Mon, 29 Jun 2026 09:00:00 +0000

In this episode of the Haskell Interlude, we are joined by Sylvain Henry, one of the all-time top contributors to GHC. He tells us about his work on GHC, the bignum library, modularization, and the secret to becoming a top contributor!

Jeremy Gibbons: Progress on the book

Sat, 27 Jun 2026 10:13:08 +0000

So, evidently I failed to fulfill my ambition to blog regularly about the contents of my planned book on Patterns in Functional Programming. But I have been making progress. I had the privilege of another sabbatical 2024-2025, in which I managed to draft the entire book.

It’s in short chapters, following the example set by Dexter Kozen in his lovely books: the idea is that each chapter is roughly one lecture’s worth of material. I had 40 to 50 chapter ideas, and 40 to 50 weeks in my sabbatical, so diligently stuck to one chapter per week for a yearâ€”if this week’s chapter wasn’t finished by the end of the week, it was put aside anyway in order to move on to the next chapter the following week.

That did mean that although I ended the year with a draft of the entire book, it did have many gaps and to-dos remaining. Reality hit at the end of my sabbatical in October 2025, and it has taken me the best part of another year around actual responsibilities to fill in most of the gaps and knock off most of the to-dos. I have also had the benefit of a number of readers (thank you, everyone!), with many helpful comments to implement.

But I have just yesterday sent a complete polished version to the publisher, Cambridge University Press, for the input of a professional copyeditor. I still have to construct an index, write solutions for the many exercises (which may appear separately from the book itself, in order to keep the length and hence the cost down), and make my own proof-reading pass. I am hoping to complete those tasks and implement the copyeditor’s eventual corrections over the summer, and that the book will finally appear before the end of 2026.

The image is my mock-up of the cover of the book. The painting is Kekub by Victor Vasarely. There is a provisional table of contents on my webpage.

Chris Reade: PenroseKiteDart User Guide

Fri, 26 Jun 2026 11:49:42 +0000

Introduction

(Updated June 2026 for PenroseKiteDart version 1.10)

PenroseKiteDart is a Haskell package with tools to experiment with finite tilings of Penrose’s Kites and Darts. It uses the Haskell Diagrams package for drawing tilings. As well as providing drawing tools, this package introduces tile graphs (Tgraphs) for describing finite tilings. (I would like to thank Stephen Huggett for suggesting planar graphs as a way to reperesent the tilings).

This document summarises the design and use of the PenroseKiteDart package.

PenroseKiteDart package is now available on Hackage.

The source files are available on GitHub at https://github.com/chrisreade/PenroseKiteDart.

There is a small art gallery of examples created with PenroseKiteDart here.

Index

1. About Penroseâ€™s Kites and Darts

The Tiles

In figure 1 we show a dart and a kite. All angles are multiples of (a tenth of a full turn). If the shorter edges are of length 1, then the longer edges are of length , where is the golden ratio.

Figure 1: The Dart and Kite Tiles

Aperiodic Infinite Tilings

What is interesting about these tiles is:

It is possible to tile the entire plane with kites and darts in an aperiodic way.

Such a tiling is non-periodic and does not contain arbitrarily large periodic regions or patches.

The possibility of aperiodic tilings with kites and darts was discovered by Sir Roger Penrose in 1974. There are other shapes with this property, including a chiral aperiodic monotile discovered in 2023 by Smith, Myers, Kaplan, Goodman-Strauss. (See the Penrose Tiling Wikipedia page for the history of aperiodic tilings)

This package is entirely concerned with Penrose’s kite and dart tilings also known as P2 tilings.

Legal Tilings

In figure 2 we add a temporary green line marking purely to illustrate a rule for making legal tilings. The purpose of the rule is to exclude the possibility of periodic tilings.

If all tiles are marked as shown, then whenever tiles come together at a point, they must all be marked or must all be unmarked at that meeting point. So, for example, each long edge of a kite can be placed legally on only one of the two long edges of a dart. The kite wing vertex (which is marked) has to go next to the dart tip vertex (which is marked) and cannot go next to the dart wing vertex (which is unmarked) for a legal tiling.

Figure 2: Marked Dart and Kite

Correct Tilings

Unfortunately, having a finite legal tiling is not enough to guarantee you can continue the tiling without getting stuck. Finite legal tilings which can be continued to cover the entire plane are called correct and the others (which are doomed to get stuck) are called incorrect. This means that decomposition and forcing (described later) become important tools for constructing correct finite tilings.

2. Using the PenroseKiteDart Package

You will need the Haskell Diagrams package (See Haskell Diagrams) as well as this package (PenroseKiteDart). When these are installed, you can produce diagrams with a Main.hs module. This should import a chosen backend for diagrams such as the default (SVG) along with Diagrams.Prelude.

    module Main (main) where
    
    import Diagrams.Backend.SVG.CmdLine
    import Diagrams.Prelude

For Penrose’s Kite and Dart tilings, you also need to import the PKD module and (optionally) the TgraphExamples module.

    import PKD
    import TgraphExamples

Then to ouput someExample figure

    fig::Diagram B
    fig = someExample

    main :: IO ()
    main = mainWith fig

Note that the token B is used in the diagrams package to represent the chosen backend for output. So a diagram has type Diagram B. In this case B is bound to SVG by the import of the SVG backend. When the compiled module is executed it will generate an SVG file. (See Haskell Diagrams for more details on producing diagrams and using alternative backends).

3. Overview of Types and Operations

Half-Tiles

In order to implement operations on tilings (decompose in particular), we work with half-tiles. These are illustrated in figure 3 and labelled RD (right dart), LD (left dart), LK (left kite), RK (right kite). The join edges where left and right halves come together are shown with dotted lines, leaving one short edge and one long edge on each half-tile (excluding the join edge). We have shown a red dot at the vertex we regard as the origin of each half-tile (the tip of a half-dart and the base of a half-kite).

Figure 3: Half-Tile pieces showing join edges (dashed) and origin vertices (red dots)

The labels are actually data constructors introduced with type operator HalfTile which has an argument type (rep) to allow for more than one representation of the half-tiles.

    data HalfTile rep 
      = LD rep -- Left Dart
      | RD rep -- Right Dart
      | LK rep -- Left Kite
      | RK rep -- Right Kite
      deriving (Show,Eq)

Tgraphs

We introduce tile graphs (Tgraphs) which provide a simple planar graph representation for finite patches of tiles. For Tgraphs we first specialise HalfTile with a triple of vertices (positive integers) to make a TileFace such as RD(1,2,3), where the vertices go clockwise round the half-tile triangle starting with the origin.

    type TileFace  = HalfTile (Vertex,Vertex,Vertex)
    type Vertex    = Int  -- must be positive

The function

    makeTgraph :: [TileFace] -> Tgraph

then constructs a Tgraph from a TileFace list after checking the TileFaces satisfy certain properties (described below). We also have

    faces :: Tgraph -> [TileFace]

to retrieve the TileFace list from a Tgraph.

As an example, the fool (short for fool’s kite and also called an ace in the literature) consists of two kites and a dart (= 4 half-kites and 2 half-darts):

    fool :: Tgraph
    fool = makeTgraph [RD (1,2,3), LD (1,3,4)   -- right and left dart
                      ,LK (5,3,2), RK (5,2,7)   -- left and right kite
                      ,RK (5,4,3), LK (5,6,4)   -- right and left kite
                      ]

To produce a diagram, we simply draw the Tgraph

    foolFigure :: Diagram B
    foolFigure = draw fool

which will produce the diagram on the left in figure 4.

Alternatively,

    foolFigure :: Diagram B
    foolFigure = labelled drawj fool

will produce the diagram on the right in figure 4 (showing vertex labels and dashed join edges).

Figure 4: Diagram of fool without labels and join edges (left), and with (right)

When any (non-empty) Tgraph is drawn, a default orientation and scale are chosen based on the lowest numbered join edge. This is aligned on the positive x-axis with length 1 (for darts) or length (for kites).

Tgraph Properties

Tgraphs are actually implemented as

    newtype Tgraph = Tgraph [TileFace]
                     deriving (Show)

but the data constructor Tgraph is not exported to avoid accidentally by-passing checks for the required properties. The properties checked by makeTgraph ensure the Tgraph represents a legal tiling as a planar graph with positive vertex numbers, and that the collection of half-tile faces are both connected and have no crossing boundaries (see note below). Finally, there is a check to ensure two or more distinct vertex numbers are not used to represent the same vertex of the graph (a touching vertex check). An error is raised if there is a problem.

Note: If the TileFaces are faces of a planar graph there will also be exterior (untiled) regions, and in graph theory these would also be called faces of the graph. To avoid confusion, we will refer to these only as exterior regions, and unless otherwise stated, face will mean a TileFace. We can then define the boundary of a list of TileFaces as the edges of the exterior regions. There is a crossing boundary if the boundary crosses itself at a vertex. We exclude crossing boundaries from Tgraphs because they prevent us from calculating relative positions of tiles locally and create touching vertex problems.

For convenience, in addition to makeTgraph, we also have

    makeUncheckedTgraph :: [TileFace] -> Tgraph
    checkedTgraph   :: [TileFace] -> Tgraph

The first of these (performing no checks) is useful when you know the required properties hold. The second performs the same checks as makeTgraph except that it omits the touching vertex check. This could be used, for example, when making a Tgraph from a sub-collection of TileFaces of another Tgraph.

Main Tiling Operations

There are three key operations on finite tilings, namely

    decompose :: Tgraph -> Tgraph
    force     :: Tgraph -> Tgraph
    compose   :: Tgraph -> Tgraph

Decompose

Decomposition (also called deflation) works by splitting each half-tile into either 2 or 3 new (smaller scale) half-tiles, to produce a new tiling. The fact that this is possible, is used to establish the existence of infinite aperiodic tilings with kites and darts. Since our Tgraphs have abstracted away from scale, the result of decomposing a Tgraph is just another Tgraph. However if we wish to compare before and after with a drawing, the latter should be scaled by a factor times the scale of the former, to reflect the change in scale.

Figure 5: fool (left) and decompose fool (right)

We can, of course, iterate decompose to produce an infinite list of finer and finer decompositions of a Tgraph

    decompositions :: Tgraph -> [Tgraph]
    decompositions = iterate decompose

Force

Force works by adding any TileFaces on the boundary edges of a Tgraph which are forced. That is, where there is only one legal choice of TileFace addition consistent with the seven possible vertex types. Such additions are continued until either (i) there are no more forced cases, in which case a final (forced) Tgraph is returned, or (ii) the process finds the tiling is stuck, in which case an error is raised indicating an incorrect tiling. [In the latter case, the argument to force must have been an incorrect tiling, because the forced additions cannot produce an incorrect tiling starting from a correct tiling.]

An example is shown in figure 6. When forced, the Tgraph on the left produces the result on the right. The original is highlighted in red in the result to show what has been added.

Figure 6: A Tgraph (left) and its forced result (right) with the original shown red

Compose

Composition (also called inflation) is an opposite to decompose but this has complications for finite tilings, so it is not simply an inverse. (See Graphs,Kites and Darts and Theorems for more discussion of the problems). Figure 7 shows a Tgraph (left) with the result of composing (right) where we have also shown (in pale green) the faces of the original that are not included in the composition – the remainder faces.

Figure 7: A Tgraph (left) and its (part) composed result (right) with the remainder faces shown pale green

Under some circumstances composing can fail to produce a Tgraph because there are crossing boundaries in the resulting TileFaces. However, we have established that

If g is a forced Tgraph, then compose g is defined and it is also a forced Tgraph.

Try Results

It is convenient to use types of the form Try a for results where we know there can be a failure. For example, compose can fail if the result does not pass the connected and no crossing boundary check, and force can fail if its argument is an incorrect Tgraph. In situations when you would like to continue some computation rather than raise an error when there is a failure, use a try version of a function.

    tryCompose :: Tgraph -> Try Tgraph
    tryForce   :: Tgraph -> Try Tgraph

We define Try as a synonym for Either ShowS (which is a monad) in module Tgraph.Try.

type Try a = Either ShowS a

(Note ShowS is String -> String). Successful results have the form Right r (for some correct result r) and failure results have the form Left (s<>) (where s is a String describing the problem as a failure report).

The function

    runTry:: Try a -> a
    runTry = either error id

will retrieve a correct result but raise an error for failure cases. This means we can always derive an error raising version from a try version of a function by composing with runTry.

    force = runTry . tryForce
    compose = runTry . tryCompose

Elementary Tgraph and TileFace Operations

The module Tgraph.Prelude defines elementary operations on Tgraphs relating vertices, directed edges, and faces. We describe a few of them here.

When we need to refer to particular vertices of a TileFace we use

    originV :: TileFace -> Vertex -- the first vertex - red dot in figure 2
    oppV    :: TileFace -> Vertex -- the vertex at the opposite end of the join edge from the origin
    wingV   :: TileFace -> Vertex -- the vertex not on the join edge

A directed edge is represented as a pair of vertices.

    type Dedge = (Vertex,Vertex)

So (a,b) is regarded as a directed edge from a to b.

When we need to refer to particular edges of a TileFace we use

    joinE  :: TileFace -> Dedge  -- shown dotted in figure 2
    shortE :: TileFace -> Dedge  -- the non-join short edge
    longE  :: TileFace -> Dedge  -- the non-join long edge

which are all directed clockwise round the TileFace. In contrast, joinOfTile is always directed away from the origin vertex, so is not clockwise for right darts or for left kites:

    joinOfTile:: TileFace -> Dedge
    joinOfTile face = (originV face, oppV face)

In the special case that a list of directed edges is symmetrically closed [(b,a) is in the list whenever (a,b) is in the list] we can think of this as an edge list rather than just a directed edge list.

For example,

    internalEdges :: Tgraph -> [Dedge]

produces an edge list, whereas

    boundary :: Tgraph -> [Dedge]

produces single directions. Each directed edge in the resulting boundary will have a TileFace on the left and an exterior region on the right. The function

    dedges :: Tgraph -> [Dedge]

produces all the directed edges obtained by going clockwise round each TileFace so not every edge in the list has an inverse in the list.

Note 1: There is now a class HasFaces (introduced in version 1.4) which includes instances for both Tgraph and [TileFace] and others. This allows some generalisations. For example

    faces         :: HasFaces a => a -> [TileFace]
    internalEdges :: HasFaces a => a -> [Dedge]
    boundary      :: HasFaces a => a -> [Dedge] 
    dedges        :: HasFaces a => a -> [Dedge] 
    nullFaces     :: HasFaces a => a -> Bool

Note 2: There is now a class HasGraph (introduced in version 1.8) which includes instances for Tgraph as well as other types used in forcing. This allows some other generalisations. For example

    compose :: HasGraph a => a -> Tgraph
    decompose :: HasGraph a => a -> Tgraph
    recoverGraph :: HasGraph a => a -> Tgraph

Patches (Scaled and Positioned Tilings)

Behind the scenes, when a Tgraph is drawn, each TileFace is converted to a Piece. A Piece is another specialisation of HalfTile. Since version 1.10 this uses two two-dimensional vectors to represent the drawn edges of the half-tile starting from the origin, fixing its scale and orientation. The whole Tgraph then becomes a list of located Pieces called a Patch.

    type Piece = HalfTile [V2 Double]
    type Patch = [Located Piece]

Piece drawing functions can use the drawnEdges (two vectors) and the joinVector (which is just the sum of the drawn edge vectors). In particular (in the TileLib module) we have

    drawPiece :: Piece -> Diagram B
    drawjPiece :: Piece -> Diagram B
    fillPieceDK :: Colour Double -> Colour Double -> Piece -> Diagram B

where the first draws the drawnEdges (the non-join edges) of a Piece, the second does the same but adds a faint dashed line for the join edge, and the third takes two colours – one for darts and one for kites, which are used to fill the piece as well as using drawPiece.

Patch is an instance of class Transformable so a Patch can be scaled, rotated, and translated for example.

Vertex Patches

It is useful to have an intermediate form between Tgraphs and Patches, that contains information about both the location of vertices (as 2D points), and the abstract TileFaces. This allows us to introduce labelled drawing functions (to show the vertex labels) which we then extend to Tgraphs. We call the intermediate form a VPatch (short for Vertex Patch).

    type VertexLocMap = IntMap.IntMap (Point V2 Double)
    data VPatch = VPatch {vLocs :: VertexLocMap,  vpFaces::[TileFace]} deriving Show

and

    makeVP :: HasGraph a => a -> VPatch

calculates vertex locations using a default orientation and scale.

VPatch is made an instance of class Transformable so a VPatch can also be scaled, translated, and rotated for example.

One essential use of this intermediate form is to be able to draw a Tgraph with labels, transformed but without the labels themselves being transformed. We can simply convert the Tgraph to a VPatch, and transform that before drawing with labels.

    labelled draw (rotate someAngle (makeVP g))

We can also align a VPatch using vertex labels.

    alignXaxis :: (Vertex, Vertex) -> VPatch -> VPatch

So if g is a Tgraph with vertex labels a and b we can align it on the x-axis with a at the origin and b on the positive x-axis (after converting to a VPatch), instead of accepting the default orientation.

    labelled draw (alignXaxis (a,b) (makeVP g))

Another use of VPatches is to share the vertex location map when drawing only subsets of the faces (see Overlaid examples in the next section).

4. Drawing in More Detail

Class Drawable

There is a class Drawable with instances Tgraph, VPatch, Patch. When the token B is in scope standing for a fixed backend then we can assume

    draw   :: Drawable a => a -> Diagram B  -- draws non-join edges
    drawj  :: Drawable a => a -> Diagram B  -- as with draw but also draws dashed join edges
    fillDK :: Drawable a => Colour Double -> Colour Double -> a -> Diagram B -- fills with colours

where fillDK clr1 clr2 will fill darts with colour clr1 and kites with colour clr2 as well as drawing non-join edges.

These are the main drawing tools. However they are actually defined for any suitable backend b so have more general types.

(Update Sept 2024) From version 1.1 onwards of PenroseKiteDart, these are

    draw ::   (Drawable a, OKBackend b) =>
              a -> Diagram b
    drawj ::  (Drawable a, OKBackend) b) =>
              a -> Diagram b
    fillDK :: (Drawable a, OKBackend b) =>
              Colour Double -> Colour Double -> a -> Diagram b

where the class OKBackend is a check to ensure a backend is suitable for drawing 2D tilings with or without labels.

In these notes we will generally use the simpler description of types using B for a fixed chosen backend for the sake of clarity.

The drawing tools are each defined via the class function drawWith using Piece drawing functions.

    class Drawable a where
        drawWith :: (Piece -> Diagram B) -> a -> Diagram B
    
    draw = drawWith drawPiece
    drawj = drawWith drawjPiece
    fillDK clr1 clr2 = drawWith (fillPieceDK clr1 clr2)

To design a new drawing function, you only need to implement a function to draw a Piece, (let us call it newPieceDraw)

    newPieceDraw :: Piece -> Diagram B

This can then be elevated to draw any Drawable (including Tgraphs, VPatches, and Patches) by applying the Drawable class function drawWith:

    newDraw :: Drawable a => a -> Diagram B
    newDraw = drawWith newPieceDraw

Class DrawableLabelled

Class DrawableLabelled is defined with instances Tgraph and VPatch, but Patch is not an instance (because this does not retain vertex label information).

    class DrawableLabelled a where
        labelColourSize :: Colour Double -> Measure Double -> (Patch -> Diagram B) -> a -> Diagram B

So labelColourSize c m modifies a Patch drawing function to add labels (of colour c and size measure m). Measure is defined in Diagrams.Prelude with pre-defined measures tiny, verySmall, small, normal, large, veryLarge, huge. For most of our diagrams of Tgraphs, we use red labels and we also find small is a good default size choice, so we define

    labelSize :: DrawableLabelled a => Measure Double -> (Patch -> Diagram B) -> a -> Diagram B
    labelSize = labelColourSize red

    labelled :: DrawableLabelled a => (Patch -> Diagram B) -> a -> Diagram B
    labelled = labelSize small

and then labelled draw, labelled drawj, labelled (fillDK clr1 clr2) can all be used on both Tgraphs and VPatches as well as (for example) labelSize tiny draw, or labelCoulourSize blue normal drawj.

Further drawing functions

There are a few extra drawing functions built on top of the above ones. The function smart is a modifier to add dashed join edges only when they occur on the boundary of a Tgraph

    smart :: HasGraph a => (VPatch -> Diagram B) -> a -> Diagram B

So smart vpdraw g will draw dashed join edges on the boundary of g before applying the drawing function vpdraw to the VPatch for g. For example the following all draw dashed join edges only on the boundary for a Tgraph g

    smart draw g
    smart (labelled draw) g
    smart (labelSize normal draw) g

When using labels, the function rotating allows a Tgraph to be drawn rotated without rotating the labels.

    rotating :: HasGraph a => Angle Double -> (VPatch -> b) -> a -> b
    rotating angle vpdraw = vpdraw . rotate angle . makeVP

So for example,

    rotating (90@@deg) (labelled draw) g

makes sense for a Tgraph g. Of course if there are no labels we can simply use

    rotate (90@@deg) (draw g)

Similarly aligning allows a Tgraph to be aligned on the X-axis using a pair of vertex numbers before drawing.

    aligning :: HasGraph a => (Vertex,Vertex) -> (VPatch -> b) -> a -> b
    aligning (a,b) vpdraw = vpdraw . alignXaxis (a,b) . makeVP

So, for example, if Tgraph g has vertices a and b, both

    aligning (a,b) draw g
    aligning (a,b) (labelled draw) g

make sense. Note that the following two examples are wrong. Even though they type check, they re-orient g without repositioning the boundary joins.

    smart (labelled draw . rotate angle) g      -- WRONG
    smart (labelled draw . alignXaxis (a,b)) g  -- WRONG

Instead use

    smartRotating angle (labelled draw) g
    smartAligning (a,b) (labelled draw) g

where

    smartRotating :: HasGraph a =>  Angle Double -> (VPatch -> Diagram B) -> a -> Diagram B
    smartAligning  :: HasGraph a => (Vertex,Vertex) -> (VPatch -> Diagram B) -> a -> Diagram B

are defined using

    smartOn :: HasGraph a => a -> (VPatch -> Diagram B) -> VPatch -> Diagram B

Here, smartOn g vpdraw vp uses the given vp for drawing boundary joins and drawing faces of g (with vpdraw) rather than converting g to a new VPatch. This assumes vp has locations for vertices in g.

The function

    drawForce :: Tgraph -> Diagram B

will (smart) draw a Tgraph g in red overlaid (using <>) on the result of force g as in figure 6. Similarly

    drawPCompose  :: Tgraph -> Diagram B

applied to a Tgraph g will draw the result of a partial composition of g as in figure 7. That is a drawing of compose g but overlaid with a drawing of the remainder faces of g shown in pale green.

Both these functions make use of sharing a vertex location map to get correct alignments of overlaid diagrams. In the case of drawForce g, we know that a VPatch for force g will contain all the vertex locations for g since force only adds to a Tgraph (when it succeeds). So when constructing the diagram for g we can use the VPatch created for force g instead of starting afresh. Similarly for drawPCompose g the VPatch for g contains locations for all the vertices of compose g so compose g is drawn using the VPatch for g instead of starting afresh.

The location map sharing is done with

    subFaces :: HasFaces a => 
                a -> VPatch -> VPatch

so that subFaces fcs vp is a VPatch with the same vertex locations as vp, but replacing the faces of vp with fcs. [Of course, this can go wrong if the new faces have vertices not in the domain of the vertex location map so this needs to be used with care. Any errors would only be discovered when a diagram is created.]

For cases where labels are only going to be drawn for certain faces, we need a version of subFaces which also gets rid of vertex locations that are not relevant to the faces. For this situation we have

    restrictTo:: HasFaces a => 
                 a -> VPatch -> VPatch

which filters out un-needed vertex locations from the vertex location map. Unlike subFaces, restrictTo checks for missing vertex locations, so restrictTo fcs vp raises an error if a vertex in fcs is missing from the keys of the vertex location map of vp.

5. Forcing in More Detail

The force rules

The rules used by our force algorithm are local and derived from the fact that there are seven possible (internal) vertex types as depicted in figure 8.

Figure 8: Seven vertex types

Our rules are shown in figure 9 (omitting mirror symmetric versions). In each case the TileFace shown yellow needs to be added in the presence of the other TileFaces shown.

Figure 9: Rules for forcing

Main Forcing Operations

To make forcing efficient we convert a Tgraph to a BoundaryState to keep track of boundary information of the Tgraph, and then calculate a ForceState which combines the BoundaryState with a record of awaiting boundary edge updates (an update map), and an UpdateGenerator. Then each face addition is carried out on a ForceState, converting back when all the face additions are complete. It makes sense to apply force (and related functions) to a Tgraph, a BoundaryState, or a ForceState, so we define a class Forcible with instances Tgraph, BoundaryState, and ForceState.

This allows us to define

    force :: Forcible a => a -> a
    tryForce :: Forcible a => a -> Try a

The first will raise an error if a stuck tiling is encountered. The second uses a Try result which produces a Left report for failures and a Right a for successful result a.

There are several other operations related to forcing including

    stepForce :: Forcible a => Int -> a -> a
    tryStepForce  :: Forcible a => Int -> a -> Try a

    addHalfDart, addHalfKite :: Forcible a => Dedge -> a -> a
    tryAddHalfDart, tryAddHalfKite :: Forcible a => Dedge -> a -> Try a

The first two force (up to) a given number of steps (=face additions) and the other four add a half dart/kite on a given boundary edge.

Update Generators

An update generator is used to calculate which boundary edges can have a certain update. There is an update generator for each force rule, but also a combined (all update) generator. The force operations mentioned above all use the default all update generator (defaultAllUGen) but there are more general (with) versions that can be passed an update generator of choice. For example

    forceWith :: Forcible a => UpdateGenerator -> a -> a
    tryForceWith :: Forcible a => UpdateGenerator -> a -> Try a

We can also define

    wholeTiles :: Forcible a => a -> a
    wholeTiles = forceWith wholeTileUpdates

where wholeTileUpdates is an update generator that just finds boundary join edges to complete whole tiles.

In fact UpdateGenerators are functions that take a BoundaryState and a focus (list of boundary directed edges) to produce an update map. Each Update is calculated as either a SafeUpdate (where two of the new face edges are on the existing boundary and no new vertex is needed) or an UnsafeUpdate (where only one edge of the new face is on the boundary and a new vertex needs to be created for a new face).

    type UpdateGenerator = BoundaryState -> [Dedge] -> Try UpdateMap
    type UpdateMap = Map.Map Dedge Update
    data Update = SafeUpdate TileFace 
                | UnsafeUpdate (Vertex -> TileFace)

Completing (executing) an UnsafeUpdate requires a touching vertex check to ensure that the new vertex does not clash with an existing boundary vertex. Using an existing (touching) vertex would create a crossing boundary so such an update has to be blocked.

Forcible Class Operations

The Forcible class operations are higher order and designed to allow for easy additions of further generic operations. They take care of conversions between Tgraphs, BoundaryStates and ForceStates. The first two are designed to create functions that return the same Forcible type as the input.

    class Forcible a where
      tryFSOp :: (ForceState -> Try ForceState) -> a -> Try a
      tryChangeBoundary :: (BoundaryState -> Try BoundaryChange) -> a -> Try a
      tryInitFS :: a -> Try ForceState

For example, given any f:: ForceState -> Try ForceState , then f can be generalised to work on any Forcible using tryFSOp f. This is used to define both tryForce and tryStepForce.

Similarly given any f:: BoundaryState -> Try BoundaryChange , then f can be generalised to work on any Forcible using tryChangeBoundary f. This is used to define tryAddHalfDart and tryAddHalfKite.

Note that the type BoundaryChange contains a resulting BoundaryState, the single TileFace that has been added, a list of edges removed from the boundary (of the BoundaryState prior to the face addition), and a list of the (3 or 4) boundary edges affected around the change that require checking or re-checking for updates.

The class function tryInitFS will create an initial ForceState for any Forcible. If the Forcible is already a ForceState it will do nothing. Otherwise it will calculate updates for the whole boundary using defaultAllUGen.

The update generator is assumed to be defaultAllUGen but this can be changed using

    tryFSOpWith :: Forcible a => UpdateGenerator -> (ForceState -> Try ForceState) -> a -> Try a

so, for example, we defined

    tryForceWith ugen = tryFSOpWith ugen tryForce

Efficient chains of forcing operations.

Note that (force . force) does the same as force, but we might want to chain other force related steps in a calculation.

For example, consider the following combination which, after decomposing a Tgraph, forces, then adds a half dart on a given boundary edge (d) and then forces again.

    combo :: Dedge -> Tgraph -> Tgraph
    combo d = force . addHalfDart d . force . decompose

Since decompose produces a Tgraph, the instances of force and addHalfDart d will have type Tgraph -> Tgraph so each of these operations, will begin and end with conversions between Tgraph and ForceState. We would do better to avoid these wasted intermediate conversions working only with ForceStates and keeping only those necessary conversions at the beginning and end of the whole sequence.

This can be done using tryFSOp. To see this, let us first re-express the forcing sequence using the Try monad, so

    force . addHalfDart d . force

becomes

    tryForce <=< tryAddHalfDart d <=< tryForce

Note that (<=<) is the Kliesli arrow which replaces composition for Monads (defined in Control.Monad). (We could also have expressed this right to left sequence with a left to right version tryForce >=> tryAddHalfDart d >=> tryForce). The definition of combo becomes

    combo :: Dedge -> Tgraph -> Tgraph
    combo d = runTry . (tryForce <=< tryAddHalfDart d <=< tryForce) . decompose

This has no performance improvement, but now we can pass the sequence to tryFSOp to remove the unnecessary conversions between steps.

    combo :: Dedge -> Tgraph -> Tgraph
    combo d = runTry . tryFSOp (tryForce <=< tryAddHalfDart d <=< tryForce) . decompose

The sequence actually has type Forcible a => a -> Try a but when passed to tryFSOp it specialises to type ForceState -> Try ForseState. This ensures the sequence works on a ForceState and any conversions are confined to the beginning and end of the sequence, avoiding unnecessary intermediate conversions.

A limitation of forcing

To avoid creating touching vertices (or crossing boundaries) a BoundaryState keeps track of locations of boundary vertices. At around 35,000 face additions in a single force operation the calculated positions of boundary vertices can become too inaccurate to prevent touching vertex problems. In such cases it is better to use

    recalibratingForce :: Forcible a => a -> a
    tryRecalibratingForce :: Forcible a => a -> Try a

These work by recalculating all vertex positions at 20,000 step intervals to get more accurate boundary vertex positions. For example, 6 decompositions of the kingGraph has 2,906 faces. Applying force to this should result in 53,574 faces but will go wrong before it reaches that. This can be fixed by calculating either

    recalibratingForce (decompositions kingGraph !!6)

or using an extra force before the decompositions

    force (decompositions (force kingGraph) !!6)

In the latter case, the final force only needs to add 17,864 faces to the 35,710 produced by decompositions (force kingGraph) !!6.

6. Advanced Operations

Guided comparison of `Tgraph`s

Asking if two Tgraphs are equivalent (the same apart from choice of vertex numbers) is a an np-hard problem. However, we do have an efficient guided way of comparing Tgraphs. In the module Tgraph.Rellabelling we have

    sameGraph :: (Tgraph,Dedge) -> (Tgraph,Dedge) -> Bool

The expression sameGraph (g1,d1) (g2,d2) asks if g2 can be relabelled to match g1 assuming that the directed edge d2 in g2 is identified with d1 in g1. Hence the comparison is guided by the assumption that d2 corresponds to d1.

It is implemented using

    tryRelabelToMatch :: (Tgraph,Dedge) -> (Tgraph,Dedge) -> Try Tgraph

where tryRelabelToMatch (g1,d1) (g2,d2) will either fail with a Left report if a mismatch is found when relabelling g2 to match g1 or will succeed with Right g3 where g3 is a relabelled version of g2. The successful result g3 will match g1 in a maximal tile-connected collection of faces containing the face with edge d1 and have vertices disjoint from those of g1 elsewhere. The comparison tries to grow a suitable relabelling by comparing faces one at a time starting from the face with edge d1 in g1 and the face with edge d2 in g2. (This relies on the fact that Tgraphs are connected with no crossing boundaries, and hence tile-connected.)

The above function is also used to implement

    tryFullUnion:: (Tgraph,Dedge) -> (Tgraph,Dedge) -> Try Tgraph

which tries to find the union of two Tgraphs guided by a directed edge identification. However, there is an extra complexity arising from the fact that Tgraphs might overlap in more than one tile-connected region. After calculating one overlapping region, the full union uses some geometry (calculating vertex locations) to detect further overlaps.

Finally we have

    commonFaces:: (Tgraph,Dedge) -> (Tgraph,Dedge) -> [TileFace]

which will find common regions of overlapping faces of two Tgraphs guided by a directed edge identification. The resulting common faces will be a sub-collection of faces from the first Tgraph. These are returned as a list as they may not be a connected collection of faces and therefore not necessarily a Tgraph.

Empires and SuperForce

In Empires and SuperForce we discussed forced boundary coverings which were used to implement both a superForce operation

    superForce:: Forcible a => a -> Forced a

and operations to calculate empires.

We will not repeat the descriptions here other than to note that

    forcedBoundaryECovering:: Tgraph -> [Forced Tgraph]

finds boundary edge coverings after forcing a Tgraph. That is, forcedBoundaryECovering g will first force g, then (if it succeeds) finds a collection of (forced) extensions to force g such that

each extension has the whole boundary of force g as internal edges.
each possible addition to a boundary edge of force g (kite or dart) has been included in the collection.

(possible here means – not leading to a stuck Tgraph when forced.) There is also

    forcedBoundaryVCovering:: Tgraph -> [Forced Tgraph]

which does the same except that the extensions have all boundary vertices internal rather than just the boundary edges. In both cases the result is a list of explicitly forced Tgraphs (discussed next).

Combinations and Explicitly Forced

We introduced a new type Forced (in v 1.3) to enable a forcible to be explictily labelled as being forced. For example

    forceF    :: Forcible a => a -> Forced a 
    tryForceF :: Forcible a => a -> Try (Forced a)
    forgetF   :: Forced a -> a

This allows us to restrict certain functions which expect a forced argument by making this explicit.

    composeF :: HasGraph a => Forced a -> Forced Tgraph

The definition makes use of theorems established in Graphs,Kites and Darts and Theorems that composing a forced Tgraph does not require a check (for connectedness and no crossing boundaries) and the result is also forced. This can then be used to define efficient combinations such as

    compForce:: (Forcible a, HasGraph a) => a -> Forced Tgraph      -- compose after forcing
    compForce = composeF . forceF

    allCompForce:: (Forcible a, HasGraph a) => a -> [Forced Tgraph] -- iterated (compose after force) while not emptyTgraph
    maxCompForce:: (Forcible a, HasGraph a) => a -> Forced Tgraph   -- last item in allCompForce (or emptyTgraph)

Note that BoundaryState, ForceState as well as Tgraph and Forced versions of these are all instances of class HasGraph.

Tracked Tgraphs

The type

    data TrackedTgraph = TrackedTgraph
       { tgraph  :: Tgraph
       , tracked :: [[TileFace]] 
       } deriving Show

has proven useful in experimentation as well as in producing artwork with darts and kites. The idea is to keep a record of sub-collections of faces of a Tgraph when doing both force operations and decompositions. A list of the sub-collections forms the tracked list associated with the Tgraph. We make TrackedTgraph an instance of class Forcible by having force operations only affect the Tgraph and not the tracked list. The significant idea is the implementation of

    decomposeTracked :: TrackedTgraph -> TrackedTgraph

Decomposition of a Tgraph involves introducing a new vertex for each long edge and each kite join. These are then used to construct the decomposed faces. For decomposeTracked we do the same for the Tgraph, but when it comes to the tracked collections, we decompose them re-using the same new vertex numbers calculated for the edges in the Tgraph. This keeps a consistent numbering between the Tgraph and tracked faces, so each item in the tracked list remains a sub-collection of faces in the Tgraph.

The function

    drawTrackedTgraph :: [VPatch -> Diagram B] -> TrackedTgraph -> Diagram B

is used to draw a TrackedTgraph. It uses a list of functions to draw VPatches. The first drawing function is applied to a VPatch for any untracked faces. Subsequent functions are applied to VPatches for the tracked list in order. Each diagram is beneath later ones in the list, with the diagram for the untracked faces at the bottom. The VPatches used are all restrictions of a single VPatch for the Tgraph, so will be consistent in vertex locations. When labels are used, there is also a drawTrackedTgraphRotating and drawTrackedTgraphAligning for rotating or aligning the VPatch prior to applying the drawing functions.

Note that the result of calculating empires (see Empires and SuperForce ) is represented as a TrackedTgraph. The result is actually the common faces of a forced boundary covering, but a particular element of the covering (the first one) is chosen as the background Tgraph with the common faces as a tracked sub-collection of faces. Hence we have

    empire1, empire2 :: Tgraph -> TrackedTgraph
    
    drawEmpire :: TrackedTgraph -> Diagram B

Figure 10 was also created using TrackedTgraphs.

Figure 10: Using a TrackedTgraph for drawing

7. Other Reading

Previous related blogs are:

Diagrams for Penrose Tiles – the first blog introduced drawing Pieces and Patches (without using Tgraphs) and provided a version of decomposing for Patches (decompPatch).
Graphs, Kites and Darts intoduced Tgraphs. This gave more details of implementation and results of early explorations. (The class Forcible was introduced subsequently).
Empires and SuperForce – these new operations were based on observing properties of boundaries of forced Tgraphs.
Graphs,Kites and Darts and Theorems established some important results relating force, compose, decompose.

Brent Yorgey: Proving the Fundamental Theorem of Arithmetic in Agda

Fri, 26 Jun 2026 00:00:00 +0000

Proving the Fundamental Theorem of Arithmetic in Agda

Posted on June 26, 2026
Tagged agda, arithmetic, theorem, proof, Agda

Share on

tl;dr: This is a fully commentated, from-scratch proof of the Fundamental Theorem of Arithmetic in Agda, intended for those who already know a bit of Agda but might benefit from reading and working through a larger example. See the Introduction and the Table of Contents below for more details.

Introduction

Earlier this spring, I was idly brainstorming potential final projects for my Functional Programming students. Having just taught my Discrete Math students the Fundamental Theorem of Arithmetic, I wondered whether formalizingI mean formalizing it from scratch: of course, the FTA is already in the Agda standard library. As I later learned, it was added to the standard library by Nathan van Doorn, aka Taneb.

it in Agda could make a nice project.

So I decided to spend about an hour trying to prove it in Agda, to gauge the level of the project. At the end of an hour, I had learned two things: (1) proving the Fundamental Theorem of Arithmetic is not an appropriate project for my students (who had only had a few weeks’ practice with Agda); (2) I was not going to be able to stop until I finished the proof myself!

Over the next week or so, I finished the proof completely from scratch—without using anything from the standard library, and without looking up any reference material. I based it only on my experience in Agda, knowledge of the relevant proofs on an informal level, and Agda techniques I’ve picked up along the way (from e.g. Conor McBride, Jacques Carette, colleagues at Penn, and elsewhere).

I decided to publish the proof, with extra commentary, in the hopes that it can be useful as an intermediate-level reference. That is, perhaps you’ve learned some basic Agda (if not, I suggest this tutorial to start) and have some basic familiarity with the Curry-Howard correspondence, but would benefit from seeing an example of a fully worked out, medium-sized proof.Another good source of information along these lines is this post by Jesper Cockx.

The resulting blog post is extremely long, but I make no apologies for that—if you want an entertaining 5-minute read, you should look elsewhere!

The entire blog post and proof is available as a literate Agda document. Even better, I have also published another version of this blog post with holes in place of almost all the proofs. For a maximal learning experience, I suggest downloading it and trying to fill in the holes yourself as you go along.

Below is a table of contents. Depending on your background, you may of course choose to skip some sections. For example, if you have already had a good deal of practice dealing with basic natural number arithmetic, equality, and inequality in Agda, you might wish to skip over those sections.

(Half of) The Fundamental Theorem of Arithmetic (Constructively)

The Fundamental Theorem of Arithmetic (FTA for short) states that any natural number $n \geq 1$ can be written as a product of zero or more primes, and moreover that this product is unique up to permutation.

For now, we are only going to prove the existence part (I may write another blog post with the uniqueness proof later). Since a constructive existence proof is really an algorithm for constructing the thing that is claimed to exist, this can also be seen as a formally verified factorization program: put any number in, get a prime factorization out. Writing a prime factorization program is not hard, of course; it’s the formal verification part that is interesting!

Stop! Before reading on, if you want to get the most out of this tutorial, I strongly recommend downloading the version with holes and trying to complete as many of the proofs as you can before reading mine!

Preliminaries

We will often make use of A and B to stand for arbitrary sets/types, so we use a variable declaration to tell Agda that it should implicitly quantify them whenever they show up as free variables. That way we don’t have to write {A B : Set} → ... all the time.

variable
  A B : Set

Basic logic

Since we’re building this completely from scratch, we start with some types to represent basic logical building blocks (via the Curry-Howard correspondence). First, the “top” type ⊤ to stand for truth, i.e. a proposition with trivial evidence:

data ⊤ : Set where
  tt : ⊤

tt is declared to be the one and only value of type ⊤.

Note that some things we define here—such as ⊤—will have the same names as they do in the Agda standard library. However, many things won’t, since I either didn’t know the standard name and made up my own, or (in a few cases) did know the standard name but didn’t like it, and made up my own anyway.

Next, the “bottom” type ⊥ with no constructors, representing falsity, along with a corresponding elimination principle, absurd. The elimination principle says that anything follows from ⊥ (“ex falso quodlibet”), and is implemented using Agda’s absurd pattern, written (). If Agda can tell that there are no possible constructors which could give rise to a value of a certain type, we can pattern-match on it with (), and are absolved of providing a right-hand side for the definition in that case.

data ⊥ : Set where

absurd : ⊥ → A
absurd ()

We can now define negation as an implication to ⊥.

¬ : Set → Set
¬ P = P → ⊥

Dependent pairs are next: a pair of values where the type of the second component can depend on the value of the first. That is, a value of type Σ A B is a value a of type A paired with a value of type B a. Via Curry-Howard, this is used to represent existential quantification: a (constructive) proof of $\exists a : A.\; B(a)$ is a value $a$ of type $A$ (the witness) paired with a proof that $a$ has property $B$ (i.e. a value of type $B(a)$).

infixr 1 _,_
data Σ (A : Set) (B : A → Set) : Set where
  _,_ : (a : A) → B a → Σ A B

We also define a projection function (we only end up needing fst; defining snd is left as an exercise for the readerThe definition of snd is trivial; writing down its type is a worthwhile exercise.

), along with a type of non-dependent pairs, corresponding to logical conjunction (and).

fst : ∀ {A B} → Σ A B → A
fst (a , _) = a

infixr 3 _×_
_×_ : (A B : Set) → Set
A × B = Σ A (λ _ → B)

Finally, we define a disjoint (tagged) union type corresponding to logical disjunction (or).

infixr 2 _⊎_
data _⊎_ (A B : Set) : Set where
  inj₁ : A → A ⊎ B
  inj₂ : B → A ⊎ B

Equality

Next, we write down the standard equality (aka identity, aka path) type, with a single constructor refl that witnesses when its two arguments are identical.It still seems somewhat magical to me that this seemingly too-simple definition encapsulates everything we want in an equality relation (well, almost everything).

We also define a convenient synonym for inequality.

infix 4 _≡_
data _≡_ (a : A) : A → Set where
  refl : a ≡ a

_≢_ : A → A → Set
x ≢ y = ¬ (x ≡ y)

Besides reflexivity, equality enjoys various properties that we will need: symmetry, transitivity, and congruence (i.e., we can apply any function to both sides of an equation).

sym : {x y : A} → x ≡ y → y ≡ x
sym refl = refl

trans : {x y z : A} → x ≡ y → y ≡ z → x ≡ z
trans refl y≡z = y≡z

cong : (f : A → B) → {x y : A} → x ≡ y → f x ≡ f y
cong _ refl = refl

Since we will spend a good amount of time reasoning about equality, it is worthwhile building up some machinery for writing more readable equality proofs. Instead of writing, say,

trans p (trans q (trans (sym r) s))

we will be able to instead write equality proofs like so:

begin
  v      ≡[ p ⟩≡
  w      ≡[ q ⟩≡
  x      ≡⟨ r ]≡
  y      ≡[ s ⟩≡
  z      ∎

The intention is that this proof shows v ≡ z, by first using p to show that v ≡ w, then q to show w ≡ x, and so on. This notation is one of my favorite applications of Agda’s mixfix operator syntax, and has several benefits:

We can avoid nested parentheses when chaining uses of transitivity.
We can automatically apply symmetry by using a left-pointing instead of right-pointing operator.
We get to explicitly mention (and have Agda check for us) all the intermediate values, making it easier to write the proof incrementally, and much easier for humans to read.

This is one of the places where I deliberately chose different operator names than the standard library, which uses _≡⟨_⟩_ and _≡⟨_⟨_. The operator names I decided to use are inspired by Conor McBride. I just like the way they look better.

infix 1 begin_
begin_ : {x y : A} → x ≡ y → x ≡ y
begin x≡y = x≡y

infixr 2 _≡[_⟩≡_
_≡[_⟩≡_ : (x : A) → {y z : A} → (x ≡ y) → (y ≡ z) → (x ≡ z)
_ ≡[ x≡y ⟩≡ y≡z = trans x≡y y≡z

infixr 2 _≡⟨_]≡_
_≡⟨_]≡_ : (x : A) → {y z : A} → (y ≡ x) → (y ≡ z) → (x ≡ z)
_ ≡⟨ y≡x ]≡ y≡z = trans (sym y≡x) y≡z

infixr 5 _∎
_∎ : (x : A) → x ≡ x
_ ∎ = refl

Finally, a few Applicative-like operators for more conveniently writing common forms of congruence. For example, instead of writing cong f x≡y, we can write f $≡ x≡y; or to use congruence on both arguments of a two-place function at once, we can write f $≡ x≡y ≡$≡ z≡w. (These operators were also inspired by Conor.)

infixl 4 _$≡_
_$≡_ : (f : A → B) → {x y : A} → x ≡ y → f x ≡ f y
f $≡ x≡y = cong f x≡y

infixl 4 _≡$_
_≡$_ : {f g : A → B} → f ≡ g → (x : A) → f x ≡ g x
f≡g ≡$ x = cong (λ h → h x) f≡g

infixl 4 _≡$≡_
_≡$≡_ : {f g : A → B} → f ≡ g → {x y : A} → x ≡ y → f x ≡ g y
f≡g ≡$≡ x≡y = trans (f≡g ≡$ _) (_ $≡ x≡y)

Natural numbers

Of course, we will need a type to represent the natural numbers. We can also tell Agda that our natural number type should correspond to its built-in notion of natural numbers, so we can use numeric literals like 2 : ℕ instead of having to write suc (suc zero).

data ℕ : Set where
  zero : ℕ
  suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}

No confusion

For our natural number type—and often, for any algebraic data type—we need to know that the constructors are

disjoint, meaning that different constructors always generate different values (so it’s a contradiction to have an equality between values built with different constructors); and
injective, meaning that if we have an equality between values built with the same constructor, we can decompose it into equalities between the components.

We can prove both of these simultaneously using a property called “no confusion”. This property and its name is well-known in the literature; for example, see McBridge or Cornes + Terrasse.

For natural numbers m and n, the type NoConf m n should be thought of as the type of evidence that m ≡ n, based on looking at the top-level constructors of m and n. If m and n have different constructors, then no evidence can possibly show that they are equal, so NoConf m n = ⊥ in that case. If m and n are both zero, then they are evidently equal, so NoConf 0 0 = ⊤. Otherwise, if m and n are both successors, NoConf m n reduces to a proof of equality between their predecessors.

NoConf : ℕ → ℕ → Set
NoConf zero zero = ⊤
NoConf zero (suc n) = ⊥
NoConf (suc m) zero = ⊥
NoConf (suc m) (suc n) = m ≡ n

Now we can prove the no confusion lemma for our natural number type, which says that NoConf m n always holds whenever m ≡ n. Since m ≡ n, we only have to deal with the cases when m and n are both zero or both a successor—but this also justifies assigning a type of ⊥ to the cases when the constructors do not match. noConf can therefore be used to strip suc from both sides of an equation, or to derive a contradiction when we have an equation between non-matching constructors.

noConf : {m n : ℕ} → m ≡ n → NoConf m n
noConf {zero} refl = tt
noConf {suc m} refl = refl

As an aside, this definition of the no confusion property uses a technique I like: defining a type starting with a capital letter, then defining a term that returns that type starting with a lowercase letter. This pattern will come up again later. Sometimes we define named types in this way just for convenience, say, to be able to refer to the type multiple times in a concise way; or, as in the above case, sometimes the type is actually defined via some nontrivial computation.

Decidable equality

We can now show how to decide equality of natural numbers. We first define a simple type representing decidability in general: Dec P represents either a proof of P, or a proof of ¬ P.You may be aware that the law of excluded middle, which says that $P \lor \neg P$ for all propositions $P$, is rejected in constructive logic. However, even though $P \lor \neg P$ does not hold for all $P$, it can still hold for certain specific propositions. Propositions $P$ for which $P \lor \neg P$ holds constructively are called decidable.

(The standard library version is much more sophisticated, but this simple version will do just fine.)

data Dec (P : Set) : Set where
  yes : P → Dec P
  no : ¬ P → Dec P

We can then prove that for any natural numbers x and y, we can decide whether x ≡ y. Notice the several different uses of the no confusion lemma: two to handle impossible situations, and one to strip suc off both sides of an equality.

_≟_ : (x y : ℕ) → Dec (x ≡ y)
zero ≟ zero = yes refl
zero ≟ suc y = no noConf
suc x ≟ zero = no noConf
suc x ≟ suc y with x ≟ y
... | yes x≡y = yes (suc $≡ x≡y)
... | no x≢y = no (λ sx≡sy → x≢y (noConf sx≡sy))

Addition

We next turn to defining addition (by pattern-matching on the left-hand argument), along with several properties of addition we will need: zero is a right identity for addition; we can pull out a suc from the right-hand argument; and addition is commutative, associative, and left-cancellable.

infixl 6 _+_
_+_ : ℕ → ℕ → ℕ
zero + y = y
suc x + y = suc (x + y)

_+0 : (n : ℕ) → (n + 0 ≡ n)
zero +0 = refl
(suc n) +0 = suc $≡ (n +0)

_+suc_ : (x y : ℕ) → (x + suc y) ≡ suc (x + y)
zero +suc y = refl
(suc x) +suc y = suc $≡ (x +suc y)

+-comm : (x y : ℕ) → x + y ≡ y + x
+-comm zero y = sym (y +0)
+-comm (suc x) y = trans (suc $≡ (+-comm x y)) (sym (y +suc x))

+-assoc : (x y z : ℕ) → (x + y) + z ≡ x + (y + z)
+-assoc zero y z = refl
+-assoc (suc x) y z = suc $≡ (+-assoc x y z)

+-cancelˡ : (x y z : ℕ) → x + y ≡ x + z → y ≡ z
+-cancelˡ zero y z x+y≡x+z = x+y≡x+z
+-cancelˡ (suc x) y z x+y≡x+z = +-cancelˡ x y z (noConf x+y≡x+z)

Multiplication

Multiplication is next: we start by defining the multiplication operation (by pattern-matching on the left-hand argument) and proving a few lemmas about multiplying by known arguments on the right. The proof of *suc is the most involved proof we have seen yet, but it ultimately just comes down to algebra, and we can make good use of our notation for writing chained equality proofs.

infixl 7 _*_
_*_ : ℕ → ℕ → ℕ
zero * y = zero
suc x * y = y + x * y

_*0 : (n : ℕ) → (n * 0 ≡ 0)
zero *0 = refl
(suc n) *0 = n *0

_*1 : (n : ℕ) → (n * 1 ≡ n)
0 *1 = refl
(suc n) *1 = suc $≡ (n *1)

_*suc_ : (x y : ℕ) → (x * suc y ≡ x + x * y)
zero *suc y = refl
(suc x) *suc y = suc $≡ (
  begin
  y + x * suc y               ≡[ (y +_) $≡ (x *suc y) ⟩≡
  y + (x + x * y)             ≡⟨ +-assoc y x (x * y) ]≡
  (y + x) + x * y             ≡[ _+_ $≡ +-comm y x ≡$ x * y ⟩≡
  (x + y) + x * y             ≡[ +-assoc x _ _ ⟩≡
  x + (y + x * y)             ∎)

We prove some standard properties of multiplication: commutativity, distributivity over addition, associativity. Again, the proofs mostly consist of a whole bunch of algebra, using the special notation for building chained equality proofs.

*-comm : (x y : ℕ) → x * y ≡ y * x
*-comm zero y = sym (y *0)
*-comm (suc x) y = begin
  y + x * y                   ≡[ y +_ $≡ *-comm x y ⟩≡
  y + y * x                   ≡⟨ y *suc x ]≡
  y * suc x                   ∎

*-distribˡ : (x y z : ℕ) → x * (y + z) ≡ x * y + x * z
*-distribˡ zero y z = refl
*-distribˡ (suc x) y z = begin
  y + z + x * (y + z)         ≡[ (y + z) +_ $≡ *-distribˡ x y z ⟩≡
  y + z + (x * y + x * z)     ≡[ +-assoc y _ _ ⟩≡
  y + (z + (x * y + x * z))   ≡⟨ y +_ $≡ +-assoc z _ _ ]≡
  y + ((z + x * y) + x * z)   ≡[ y +_ $≡ (_+_ $≡ +-comm z _ ≡$ x * z) ⟩≡
  y + ((x * y + z) + x * z)   ≡[ y +_ $≡ +-assoc (x * y) _ _ ⟩≡
  y + (x * y + (z + x * z))   ≡⟨ +-assoc y _ _ ]≡
  y + x * y + (z + x * z)     ∎

*-distribʳ : (x y z : ℕ) → (x + y) * z ≡ x * z + y * z
*-distribʳ x y z = begin
  (x + y) * z                 ≡[ *-comm (x + y) _ ⟩≡
  z * (x + y)                 ≡[ *-distribˡ z _ _ ⟩≡
  z * x + z * y               ≡[ _+_ $≡ *-comm z _ ≡$≡ *-comm z _ ⟩≡
  x * z + y * z               ∎

*-assoc : (x y z : ℕ) → (x * y) * z ≡ x * (y * z)
*-assoc zero y z = refl
*-assoc (suc x) y z = begin
  (y + x * y) * z             ≡[ *-distribʳ y _ _ ⟩≡
  y * z + (x * y) * z         ≡[ y * z +_ $≡ *-assoc x _ _ ⟩≡
  y * z + x * (y * z)         ∎

Finally, we prove that multiplication is left-cancellative. This proof is somewhat tricky—in the case that x, y, and z are all successors, we need to use the induction hypothesis (i.e. a recursive call to *-cancelˡ) on x and the predecessors of y and z, using the fact that + is left-cancellative to construct the required input equality.

*-cancelˡ : (x y z : ℕ) → (0 ≢ x) → x * y ≡ x * z → y ≡ z
*-cancelˡ zero y z x≢0 xy≡xz = absurd (x≢0 refl)
*-cancelˡ (suc x) zero zero x≢0 xy≡xz = refl
*-cancelˡ (suc x) zero (suc z) x≢0 xy≡xz = absurd (noConf (trans (sym (x *0)) xy≡xz))
*-cancelˡ (suc x) (suc y) zero x≢0 xy≡xz = absurd (noConf (trans xy≡xz (x *0)))
*-cancelˡ (suc x) (suc y) (suc z) x≢0 xy≡xz = suc $≡
  ( *-cancelˡ (suc x) y z x≢0
    ( +-cancelˡ (suc x) (suc x * y) (suc x * z)
      ( begin
          suc x + suc x * y   ≡⟨ (suc x) *suc y ]≡
          suc x * suc y       ≡[ xy≡xz ⟩≡
          suc x * suc z       ≡[ (suc x) *suc z ⟩≡
          suc x + suc x * z   ∎
      )
    )
  )

Inequality

Next, we give a standard definition of the “less than or equal to” relation on natural numbers. Note that the structure of a proof of $x \leq y$ exactly matches the structure of $x$ itself.

data _≤_ : ℕ → ℕ → Set where
  zle : {n : ℕ} → zero ≤ n
  sle : {m n : ℕ} → m ≤ n → suc m ≤ suc n

We also prove some standard properties of $\leq$: it is reflexive and transitive, and is related to suc in various ways.

≤-refl : {m : ℕ} → m ≤ m
≤-refl {zero} = zle
≤-refl {suc m} = sle ≤-refl

≤-trans : {x y z : ℕ} → x ≤ y → y ≤ z → x ≤ z
≤-trans zle y≤z = zle
≤-trans (sle x≤y) (sle y≤z) = sle (≤-trans x≤y y≤z)

≤-sucr : {m n : ℕ} → m ≤ n → m ≤ suc n
≤-sucr zle = zle
≤-sucr (sle m≤n) = sle (≤-sucr m≤n)

≤-sucl : {m n : ℕ} → suc m ≤ n → m ≤ n
≤-sucl (sle sm≤n) = ≤-sucr sm≤n

≤-pred : {x y : ℕ} → suc x ≤ suc y → x ≤ y
≤-pred (sle sx≤sy) = sx≤sy

For convenience, we define $<$ in terms of $\leq$, and prove a few properties: any number is less than its successor, and $<$ is transitive and non-reflexive.

_<_ : ℕ → ℕ → Set
x < y = suc x ≤ y

_<suc : (x : ℕ) → x < suc x
_<suc zero = sle zle
_<suc (suc x) = sle (x <suc)

<-trans : {x y z : ℕ} → x < y → y < z → x < z
<-trans (sle x<y) (sle y<z) = ≤-trans (sle x<y) (≤-sucr y<z)

x≮x : {x : ℕ} → ¬ (x < x)
x≮x {zero} = λ ()
x≮x {suc x} = λ { (sle x<x) → x≮x x<x}

Relationships among equality and inequality

Of course, equality, $<$ and $\leq$ have various relationships that we will need. First, equality implies $\leq$.

≡→≤ : {x y : ℕ} → x ≡ y → x ≤ y
≡→≤ refl = ≤-refl

Next, $x < y$ implies that $x$ and $y$ are not related by $\equiv$ or $\geq$. The first lemma in particular—that $<$ implies $\not\equiv$—gets used quite a bit. Note that it can be read in two equivalent ways: on the surface, it is a way to turn a proof of $x < y$ into a proof of $x \not\equiv y$; but since $x \not\equiv y$ is really an abbreviation for $(x \equiv y) \to \bot$, it can be used to derive a contradiction if we have proofs that $x < y$ and also $x \equiv y$.

<→≢ : {x y : ℕ} → x < y → x ≢ y
<→≢ x<y refl = x≮x x<y

<→≱ : {x y : ℕ} → x < y → ¬ (y ≤ x)
<→≱ (sle x<y) (sle y≤x) = <→≱ x<y y≤x

If $x \leq y$ but they are not equal, then $x < y$.

≤≢→< : {x y : ℕ} → x ≤ y → x ≢ y → x < y
≤≢→< {y = zero} zle x≢y = absurd (x≢y refl)
≤≢→< {y = suc y} zle x≢y = sle zle
≤≢→< (sle x≤y) x≢y = sle (≤≢→< x≤y (λ m≡n → x≢y (suc $≡ m≡n)))

We will need a form of transitivity that says if $x \leq y$ and $y < z$, then $x < z$, as well as the other way around.

≤-<-trans : {x y z : ℕ} → x ≤ y → y < z → x < z
≤-<-trans x≤y (sle y<z) = ≤-trans (sle x≤y) (sle y<z)

<-≤-trans : {x y z : ℕ} → x < y → y ≤ z → x < z
<-≤-trans (sle x<y) y≤z = ≤-trans (sle x<y) y≤z

Finally, a very specific lemma we will need: if a number is not equal to either 0 or 1, then it must be greater than or equal to 2.

¬01-is-≥2 : (a : ℕ) → (a ≢ 0) → (a ≢ 1) → (2 ≤ a)
¬01-is-≥2 zero a≢0 a≢1 = absurd (a≢0 refl)
¬01-is-≥2 (suc zero) a≢0 a≢1 = absurd (a≢1 refl)
¬01-is-≥2 (suc (suc a)) a≢0 a≢1 = sle (sle zle)

Arithmetic and inequality

The last lemmas we need relate arithmetic operations and inequality. First, adding and multiplying cannot make anything smaller (unless we multiply by zero, of course).

≤+ : {x y : ℕ} → x ≤ (x + y)
≤+ {zero} = zle
≤+ {suc x} = sle ≤+

≤* : {x y : ℕ} → (x ≢ 0) → y ≤ (x * y)
≤* {zero} x≢0 = absurd (x≢0 refl)
≤* {suc x} x≢0 = ≤+

As a result, if we know that one thing is equal to a sum or product of other things, we can conclude something about their relative sizes.

+→≤ : {x y z : ℕ} → x + y ≡ z → x ≤ z
+→≤ refl = ≤+

+→< : {x y z : ℕ} → 0 < y → x + y ≡ z → x < z
+→< {x} {suc y} _ x+y≡z = +→≤ (trans (sym (x +suc y)) x+y≡z)

*→≤ : {x y z : ℕ} → (y ≢ 0) → y * x ≡ z → x ≤ z
*→≤ {x} {y} y≢0 refl = ≤* y≢0

Divisibility, primes, and composites

With the preliminaries out of the way, we can finally get on with the meat of the problem—and we finally get to make use of a dependent pair! A constructive proof that a divides b is a specific natural number witness k, along with a proof that k * a ≡ b.

_∣_ : ℕ → ℕ → Set
a ∣ b = Σ ℕ (λ k → k * a ≡ b)

Proofs of divisibility are unique—that is, for given $a$ and $b$ there is at most one value of $k$ such that $ka = b$. We won’t need this, but it follows easily from the fact that multiplication is cancellative. More interesting is the fact that divisibility is decidable—that is, for given numbers $a$ and $b$ we can calculate either a proof that $a \mid b$, or a proof that $\neg (a \mid b)$. This will play a starring role later on—to factor a number we need to be able to try potential divisors and find out whether they work—but proving it is not easy! It will take us several hundred more lines of Agda to get there.

In any case, using this notion of divisibility, we can now define prime and composite numbers. A number $n$ is defined to be prime if it is at least two, and every $2 \leq d < n$ does not divide $n$.

Prime : ℕ → Set
Prime n = (2 ≤ n) × (∀ (d : ℕ) → (d < n) → (2 ≤ d) → ¬ (d ∣ n))

One could equivalently define primality by saying that any divisor of $n$ must be equal to $1$ or $n$; I just decided I liked this formulation better, especially because it directly matches up with the way we will test a number for primality later.

A composite number is one that has a nontrivial divisor—that is, a number $d$ such that $2 \leq d < n$ and $d$ divides $n$.Note that we could easily prove that if $n$ is prime then $n$ is not composite, and likewise if $n$ is composite then it is not prime, but we won’t end up needing these lemmas.

Composite : ℕ → Set
Composite n = Σ ℕ (λ d → 2 ≤ d × d < n × d ∣ n)

Unlike proofs of divisibility, proofs of Composite n are not unique. For example, we could prove Composite 12 by showing that $2$ is a nontrivial divisor of $12$, or by showing that $3$ is. Although this does not matter from a purely logical point of view, it matters computationally; in general, we care which specific proof of Composite n we have.

Nontrivial divisors come in pairs

Before moving on to other things, we will prove a lemma about composite numbers. If $n$ is composite, by definition it has a nontrivial divisor $a$; but this means it must also have a second nontrivial divisor $b$ such that $ab = n$. This fact seems almost trivial to us. Indeed, it’s easy to show that if $n$ has a divisor $a$, then it must have another divisor $b$ such that $ab = n$. The tricky part is showing that if $a$ is a nontrivial divisor, then $b$ is also nontrivial. The proof relies on much of the infrastructure we have built up about natural numbers, multiplication, and inequality.

First, we define a type representing two factors of a number $n$: a pair of proofs that $n$ is composite (i.e. two nontrivial divisors of $n$), along with a proof that the product of those divisors is $n$.

FactorsOf : ℕ → Set
FactorsOf n = Σ (Composite n × Composite n) (λ {(f₁ , f₂) → fst f₁ * fst f₂ ≡ n})

Now, we prove that if $n$ is composite, then it has two nontrivial factors. We begin by pattern-matching on the proof that $n$ is composite, which consists of a divisor $a$, evidence that $a$ is nontrivial (i.e. $2 \leq a$ and $a < n$), and a proof that $a$ is a divisor of $n$, which itself consists of a number $b$ paired with a proof that $ba = n$.

factorsOf : (n : ℕ) → Composite n → FactorsOf n
factorsOf n (a , 2≤a , a<n , b , ba≡n) =

To construct the proof of FactorsOf n, we need two proofs of Composite n along with a proof that the product of the two divisors is $n$. We already have a proof that $ba = n$, so we use that, with $a$ as the second divisor (replicating the corresponding proof of Composite n), and $b$ as the first. Proving that $b$ is a divisor of $n$ is easy: $a$ is the witness, and proving that $ab = n$ is easy since we already know $ba = n$ and multiplication is commutative. The only thing left is to prove that $b$ is nontrivial, i.e. that $2 \leq b$ and $b < n$.

  ((b , 2≤b , b<n , a , trans (*-comm a b) ba≡n) , (a , 2≤a , a<n , b , ba≡n)) , ba≡n

First, we need a lemma that $0 < n$, which follows because $0 < 1 < a < n$ (remember that a proof of $1 < a$ is actually defined to be the same thing as a proof of $2 \leq a$).

 where
  0<n : 0 < n
  0<n = <-trans (sle zle) (<-trans 2≤a a<n)

Next, we tackle $2 \leq b$, by showing that $b$ can’t possibly be $0$ or $1$ (using our previous lemma that anything not equal to 0 or 1 must be greater than or equal to 2).

  2≤b : 2 ≤ b
  2≤b = ¬01-is-≥2 b

If $b$ were $0$, then $ba = n$ would imply $0 = n$, but we know $0 < n$, so this is a contradiction.

    (λ b≡0 → <→≢ 0<n
      (begin
        0                     ≡[ refl ⟩≡
        0 * a                 ≡⟨ _*_ $≡ b≡0 ≡$ a ]≡
        b * a                 ≡[ ba≡n ⟩≡
        n                     ∎
      )
    )

If $b$ were $1$, then $ba = n$ would imply $a = n$, but we know $a < n$, so this is also a contradiction.

    (λ b≡1 → <→≢ a<n
      (begin
        a                     ≡⟨ a *1 ]≡
        a * 1                 ≡[ *-comm a 1 ⟩≡
        1 * a                 ≡⟨ _*_ $≡ b≡1 ≡$ a ]≡
        b * a                 ≡[ ba≡n ⟩≡
        n                     ∎
      )
    )

Finally, we prove $b < n$, by showing $b \leq n$ and $b \neq n$.

  b<n : b < n
  b<n = ≤≢→<

$b \leq n$ since $ba = n$ and $a$ is not zero (if $a$ were zero it would contradict the fact that $2 \leq a$).

    (*→≤ (λ a≡0 → <→≢ (<-trans (sle zle) 2≤a) (sym a≡0)) (trans (*-comm a b) ba≡n))

$b \neq n$, since $b = n$ together with $ba = n$ would imply $a = 1$ (since multiplication is cancellative), but $2 \leq a$ so it cannot equal 1.

    (λ b≡n → <→≢ 2≤a
      (sym
        (*-cancelˡ n a 1 (<→≢ 0<n)
          (begin
            n * a             ≡⟨ _*_ $≡ b≡n ≡$ a ]≡
            b * a             ≡[ ba≡n ⟩≡
            n                 ≡⟨ n *1 ]≡
            n * 1             ∎
          )
        )
      )
    )

Division

Let’s start working our way towards proving that divisibility is decidable. To check whether $d \mid n$, the usual idea would be to divide $n$ by $d$ and check whether we get a remainder of zero. So we need to formalize this notion of division with remainder.

Specifically, when we divide $n$ by $d$, we expect to get a quotient $q$ and a remainder $r$, such that $r + qd = n$, and $0 \leq r < d$. The first condition, $r + qd = n$, just defines what we mean by division: $n$ is $q$ times $d$, plus a remainder of $r$. The second condition will ensure that the result is unique. We wouldn’t want to divide $17$ by $2$ and end up with a quotient of $6$ and a remainder of $5$; the remainder should be as small as possible.

The DivMod type simply encodes these requirements.

data DivMod (n d q r : ℕ) : Set where
  DM : (r + q * d ≡ n) → (r < d) → DivMod n d q r

We can prove a few lemmas about DivMod. First, whenever we have DivMod n d q r, then d must be positive, since $r < d$ and $r$ is a natural number.

divMod→0<d : {n d q r : ℕ} → DivMod n d q r → 0 < d
divMod→0<d (DM _ r<d) = ≤-<-trans zle r<d

We can also show that for nonzero $d$, the remainder is zero if and only if $d \mid n$:

mod0→divides : (n d : ℕ) {q : ℕ} → DivMod n d q 0 → d ∣ n
mod0→divides n d {q} (DM eq _) = q , eq

divides→mod0 : (n d : ℕ) → (0 < d) → d ∣ n → Σ ℕ (λ q → DivMod n d q 0)
divides→mod0 n d 0<d (q , qd≡n) = q , (DM qd≡n 0<d)

We would also like to show that if the remainder when dividing $n$ by $d$ is not zero, then $d$ does not divide $n$. This is almost the contrapositive of divides→mod0—which would be trivial to show—but not quite: I said “the” remainder, but actually we don’t yet know that the quotient and remainder are unique! Perhaps we could get a remainder of 0 and some other remainder for the same $n$ and $d$, by choosing different quotients?

Of course, quotients and remainders are unique: that is, if $q_1, r_1$ and $q_2, r_2$ both satisfy the properties to be the quotient and remainder of $n$ divided by $d$, then in fact $q_1 = q_2$ and $r_1 = r_2$. But how can we prove this? The usual idea is to look at the difference $r_1 - r_2 = dq_1 - dq_2$, which is divisible by $d$; but since $r_1 < d$ and $r_2 < d$, the only way for the difference $r_1 - r_2$ to be divisible by $d$ is if in fact $r_1 - r_2 = 0$. From here we can also derive $q_1 = q_2$ via algebra.

Subtraction, eh? In order to formalize this, it seems as though we might need to define the integers… but there is a better way!

Absolute difference

The previous informal argument mentioned the difference $r_1 - r_2$. But we could just as easily have talked about $r_2 - r_1$ instead, and the same argument would work just as well. This observation shows that we do not actually care about the (signed) difference between $r_1$ and $r_2$, but only the distance between them. This means we can just stick to our well-loved natural numbers, and define a commutative absolute difference function which computes the nonnegative distance between its two arguments, like so:

∥_-_∥ : ℕ → ℕ → ℕ
∥ zero - y ∥ = y
∥ suc x - zero ∥ = suc x
∥ suc x - suc y ∥ = ∥ x - y ∥

Of course, we will need a lot of small lemmas about the properties of this operation. We can start by proving that the distance between two numbers is 0 if and only if they are equal:

diff0 : (x : ℕ) → 0 ≡ ∥ x - x ∥
diff0 zero = refl
diff0 (suc x) = diff0 x

diff0→≡ : {x y : ℕ} → 0 ≡ ∥ x - y ∥ → x ≡ y
diff0→≡ {zero} {zero} eq = eq
diff0→≡ {suc x} {suc y} eq = suc $≡ diff0→≡ eq

Next, the distance between any number and 0 is the number itself, and the distance function is commutative.

∥x-0∥≡x : (x : ℕ) → ∥ x - 0 ∥ ≡ x
∥x-0∥≡x zero = refl
∥x-0∥≡x (suc x) = refl

diff-comm : {x y : ℕ} → ∥ x - y ∥ ≡ ∥ y - x ∥
diff-comm {zero} {zero} = refl
diff-comm {zero} {suc y} = refl
diff-comm {suc x} {zero} = refl
diff-comm {suc x} {suc y} = diff-comm {x} {y}

A key lemma supporting the argument outlined in the previous section is that if $x$ and $y$ are both less than $d$, so is their absolute difference.

diff-< : {x y d : ℕ} → x < d → y < d → ∥ x - y ∥ < d
diff-< {zero} {y} x<d y<d = y<d
diff-< {suc x} {zero} x<d y<d = x<d
diff-< {suc x} {suc y} x<d y<d = diff-< {x} {y} (<-trans (x <suc) x<d) (<-trans (y <suc) y<d)

We can also cancel the same thing being added to both sides, or factor out the same thing being multiplied on both sides.

diff-cancelˡ : (a b c : ℕ) → ∥ (a + b) - (a + c) ∥ ≡ ∥ b - c ∥
diff-cancelˡ zero b c = refl
diff-cancelˡ (suc a) b c = diff-cancelˡ a b c

diff-distribʳ : (x y d : ℕ) → ∥ x * d - y * d ∥ ≡ ∥ x - y ∥ * d
diff-distribʳ zero y d = refl
diff-distribʳ (suc x) zero d = ∥x-0∥≡x (d + x * d)
diff-distribʳ (suc x) (suc y) d = begin
  ∥ (d + x * d) - (d + y * d) ∥         ≡[ diff-cancelˡ d (x * d) (y * d) ⟩≡
  ∥ x * d - y * d ∥                     ≡[ diff-distribʳ x y d ⟩≡
  ∥ x - y ∥ * d                         ∎

Another key lemma is that if $w + x = y + z$, then $\|w - y\| = \|x - z\|$ (sub₂ below). Personally, I found this quite tricky to prove. The best approach I found was to first prove the simpler lemma that $x + y = z$ implies $x = \| z - y \|$ (sub₁), which can then be used in several places in the proof of sub₂.

sub₁ : {x y z : ℕ} → x + y ≡ z → x ≡ ∥ z - y ∥
sub₁ {zero} {y} {z} refl = diff0 y
sub₁ {suc x} {zero} {suc z} x+y≡z =
  begin
    suc x                     ≡⟨ suc $≡ x +0 ]≡
    suc (x + 0)               ≡[ x+y≡z ⟩≡
    suc z                     ∎
sub₁ {suc x} {suc y} {suc z} x+y≡z =
  sub₁ {suc x} {y} {z}
    (noConf (trans (suc $≡ sym (x +suc y)) x+y≡z))

sub₂ : {w x y z : ℕ} → w + x ≡ y + z → ∥ w - y ∥ ≡ ∥ x - z ∥
sub₂ {zero} {x} {y} {z} w+x≡y+z = sub₁ (sym w+x≡y+z)
sub₂ {suc w} {x} {zero} {z} w+x≡y+z = trans (sub₁ w+x≡y+z) (diff-comm {z})
sub₂ {suc w} {x} {suc y} {z} w+x≡y+z = sub₂ {w} (noConf w+x≡y+z)

Quotient and remainder are unique

We can now return to prove that quotient and remainder are unique. First, we show that zero is the only multiple of $d$ which is less than $d$.

∣<→0 : {d x : ℕ} → d ∣ x → x < d → 0 ≡ x
∣<→0 (zero , ad≡x) x<d = ad≡x
∣<→0 (suc a , ad≡x) x<d = absurd (<→≱ x<d (+→≤ ad≡x))

And now for the main event: if we have both DivMod n d q₁ r₁ and DivMod n d q₂ r₂, then in fact the qs and rs must be the same.

divModUnique : {n d q₁ r₁ q₂ r₂ : ℕ} → DivMod n d q₁ r₁ → DivMod n d q₂ r₂ → (q₁ ≡ q₂) × (r₁ ≡ r₂)
divModUnique {n} {d} {q₁} {r₁} {q₂} {r₂} dm@(DM r₁+q₁d≡n r₁<d) (DM r₂+q₂d≡n r₂<d) = q₁≡q₂ , r₁≡r₂
 where

Since $r_1 + q_1d = n$ and $r_2 + q_2d = n$, by transitivity and symmetry we have $r_1 + q_1d = r_2 + q_2d$; then by the sub₂ lemma, $\|r_1 - r_2\| = \|q_1d - q_2d\|$.

  rem-diff : ∥ r₁ - r₂ ∥ ≡ ∥ q₁ * d - q₂ * d ∥
  rem-diff = sub₂ {r₁} (trans r₁+q₁d≡n (sym r₂+q₂d≡n))

Next, we can show that $d$ divides the absolute difference $\|r_1 - r_2\|$, by factoring it out of $\|q_1 d - q_2 d\|$.

  d∣r₁-r₂ : d ∣ ∥ r₁ - r₂ ∥
  d∣r₁-r₂ = ∥ q₁ - q₂ ∥ ,
    (begin
      ∥ q₁ - q₂ ∥ * d         ≡⟨ diff-distribʳ q₁ q₂ d ]≡
      ∥ q₁ * d - q₂ * d ∥     ≡⟨ rem-diff ]≡
      ∥ r₁ - r₂ ∥             ∎
    )

We can then put three lemmas together to conclude $r_1 = r_2$: first, since $r_1$ and $r_2$ are both less than $d$, so is their absolute difference; since $d$ also divides the absolute difference, the absolute difference must be zero; and finally, an absolute difference of zero means $r_1$ and $r_2$ must be equal.

  r₁≡r₂ : r₁ ≡ r₂
  r₁≡r₂ = diff0→≡ (∣<→0 d∣r₁-r₂ (diff-< r₁<d r₂<d))

From here, proving $q_1 = q_2$ just requires some algebra.

  dq₁≡dq₂ : d * q₁ ≡ d * q₂
  dq₁≡dq₂ = +-cancelˡ r₁ (d * q₁) (d * q₂)
    (begin
      r₁ + d * q₁             ≡[ r₁ +_ $≡ *-comm d q₁ ⟩≡
      r₁ + q₁ * d             ≡[ r₁+q₁d≡n ⟩≡
      n                       ≡⟨ r₂+q₂d≡n ]≡
      r₂ + q₂ * d             ≡[ _+_ $≡ sym r₁≡r₂ ≡$≡ *-comm q₂ d ⟩≡
      r₁ + d * q₂             ∎
    )

  q₁≡q₂ : q₁ ≡ q₂
  q₁≡q₂ = *-cancelˡ d q₁ q₂ (<→≢ (divMod→0<d dm)) dq₁≡dq₂

Finally, we can use uniqueness of quotients and remainders to show the lemma we wanted about divisibility and remainders: if $n$ divided by $d$ has some nonzero number as remainder, then $d$ does not divide $n$. If $d$ did divide $n$, then we know we would get a remainder of $0$; but since remainders are unique, we can’t have both a zero and nonzero remainder.

modS→¬divides : (n d : ℕ) {q r : ℕ} → DivMod n d q (suc r) → ¬ (d ∣ n)
modS→¬divides n d dm d∣n with divides→mod0 n d (divMod→0<d dm) d∣n
... | q₂ , dm₂ with divModUnique dm dm₂
... | q₁≡q₂ , ()

The division algorithm, take 1

So, given natural numbers $n$ and $d$, how do we compute the quotient and remainder? We can write down a type DivAlg that expresses what we want: given some $n$ and $d$, DivAlg n d represents the result of the division algorithm, that is, a pair of numbers $(q,r)$ such that DivMod n d q r holds.

DivAlg : ℕ → ℕ → Set
DivAlg n d = Σ (ℕ × ℕ) (λ { (q , r) → DivMod n d q r })

Then we want a function with a type something like (n d : ℕ) → DivAlg n d (actually this type is not quite correct—can you see why?). How can we write something with this type?

One simple idea, expressed imperatively, is to start with $q = 0$. Now, as long as $n \geq d$, subtract $d$ from $n$ and add one to $q$—if we can find $q$ and $r$ such that $r + qd = n - d$, then $r + (q+1)d = n$. Eventually, $n$ must land in the range $0 \leq n < d$, in which case it will be the remainder, and the current value of $q$ will be the quotient.

Construct the evidence you would like to pattern-match on

That’s the idea, but turning this into a verified constructive algorithm will take some work. First, let’s formalize the idea of testing whether $n$ is less than $d$, and decreasing it by $d$ if not. We’d rather not actually deal with subtraction, so the idea is to generate either a proof that $n < d$, or another number $n'$ along with a proof that $n' + d = n$. We encapsulate this in the following type Cmp:

data Cmp (n d : ℕ) : Set where
  LT : n < d → Cmp n d
  GE : (n′ : ℕ) → (n′ + d ≡ n) → Cmp n d

Cmp n d represents the result of comparing $n$ and $d$, and is equivalent to having either $n < d$ or $n \geq d$, but expressed in a form that is more directly useful to us. Construct the evidence you would like to pattern-match on! That is, in general, evidence for a proposition $P$ can take many logically equivalent forms, and you should pick the form that will make your life easiest at the use site, even if it means you have to work harder to construct it in the first place. You can write standalone lemmas for constructing your evidence; but pattern-matching it will happen in the middle of some bigger proof which ought not to be cluttered by calls to conversion lemmas.

To construct evidence for Cmp n d, we write the function decreaseBy? which decides whether we can decrease n by d or not. Writing this function is a bit more work than writing something of type (n d : ℕ) → (n < d) ⊎ (d ≤ n), but our work will pay off later!

_decreaseBy?_ : (n d : ℕ) → Cmp n d
zero decreaseBy? zero = GE 0 refl
zero decreaseBy? suc d = LT (sle zle)
suc n decreaseBy? zero = GE (suc n) ((suc n) +0)
suc n decreaseBy? suc d with n decreaseBy? d
... | LT n<d = LT (sle n<d)
... | GE n′ n′+d≡n = GE n′ (trans (n′ +suc d) (suc $≡ n′+d≡n))

We can also write a helper function incDivMod which encodes the observation from before, that if $r + qd = n-d$, then $r + (q+1)d = n$. Of course we don’t actually want to use subtraction, so instead of writing $n-d$, we work in terms of an $n'$ such that $n' + d = n$. Proving this requires only some straightforward algebra.

incDivMod : {n′ n d q r : ℕ} → n′ + d ≡ n → DivMod n′ d q r → DivMod n d (suc q) r
incDivMod {n′} {n} {d} {q} {r} n′+d≡n (DM r+qd≡n′ r<d) = DM r+d+qd≡n r<d
 where
  r+d+qd≡n : r + (d + q * d) ≡ n
  r+d+qd≡n = begin
    r + (d + q * d)           ≡⟨ +-assoc r _ _ ]≡
    (r + d) + q * d           ≡[ _+_ $≡ +-comm r _ ≡$ q * d ⟩≡
    (d + r) + q * d           ≡[ +-assoc d _ _ ⟩≡
    d + (r + q * d)           ≡[ d +_ $≡ r+qd≡n′ ⟩≡
    d + n′                    ≡[ +-comm d _ ⟩≡
    n′ + d                    ≡[ n′+d≡n ⟩≡
    n                         ∎

Now it seems like we have everything we need to write the division algorithm as a recursive algorithm: given $n$ and $d$, check whether $n$ can be decreased by $d$ or not. If not, we can return $q = 0$ and $r = n$. Otherwise, recurse on $n - d$, returning the same remainder and an incremented quotient from whatever the recursive call returns, using incDivMod to discharge the proof obligation. It’s just a few lines of code, right?

module DivModBad where

  {-# NON_TERMINATING #-}
  divAlg : (n d : ℕ) → DivAlg n d
  divAlg n d with n decreaseBy? d
  ... | LT n<d = (0 , n) , (DM (n +0) n<d)
  ... | GE n′ n′+d≡n with divAlg n′ d
  ... | (q , r) , dm = (suc q , r) , (incDivMod n′+d≡n dm)

Well, as you can see, it is just a few lines of code, but all is not well: although this function typechecks, Agda can’t tell that it is terminating! (I added the NON_TERMINATING pragma so I could include this bad version of divAlg in the code without causing an error.) The problem is that the recursive call to divAlg is on n′, which is not a subterm of n, but instead comes from the call to decreaseBy?. Agda has no way of knowing whether the result from some random function call is going to end up being smaller than the original input.

Now, you and I can both see that this function does indeed terminate, but we just need a way to convince Agda of this fact… right?

…have you spotted the flaw? Remember how I mentioned that the type (n d : ℕ) → DivAlg n d is not quite right? In fact, the above bad implementation of divMod is not terminating, and Agda is quite right to be worried! In particular, the function recurses infinitely when given an input of $d = 0$, since it will keep subtracting $0$ from $n$ forever. This makes sense, of course: everyone knows you can’t divide by zero because it makes the universe go into infinite recursion.

The correct type for divAlg is (n d : ℕ) → (0 < d) → DivAlg n d, but we’re still going to have trouble convincing Agda that our algorithm is terminating. In order to do so, we need to take a detour through well-founded induction.

Well-founded induction

Normally, Agda only allows functions that are structurally recursive—that is, functions which make recursive calls on syntactic subterms of their inputs. (Agda’s termination checking is a bit more sophisticated than that, but that’s the basic idea.) However, we can use basic structural induction to bootstrap our way into more exotic forms. In particular, we are going to define something called well-founded induction.Note that I will use the terms “recursion” and “induction” more or less interchangeably. In some contexts, people make a distinction between the terms (typically a recursion principle is a less-dependently-typed version of an induction principle), but in this context, inductive proofs correspond, via Curry-Howard, to (suitably restricted) recursive functions, so “induction” and “recursion” describe the same thing from a logical and computational viewpoint, respectively.

The idea of well-founded induction starts with the general idea of a relation. A relation on A is just a function that takes two values of type A and produces a type, representing evidence that the two values are related (according to whatever kind of relationship we have in mind).

Rel : Set → Set₁
Rel A = A → A → Set

We have already seen quite a few relations, such as equality, $<$, $\leq$, and divisibility.

Suppose we’re writing a recursive function, with some relation $\prec$ in mind, and for a given input $x$ we’re only allowed to make recursive calls on values $y$ such that $y \prec x$. If $\prec$ is the “is a syntactic subterm of” relation, then we get structural recursion as usual. But what if $\prec$ is some other relation? What needs to be true about $\prec$ for this to make sense? In particular, how can we be sure that the function won’t get stuck in infinite recursion?

One’s first instinct might be to say that $y \prec x$ needs to imply that $y$ is “smaller than” $x$ somehow. But what does “smaller than” mean? And in fact, “smaller than” doesn’t always work: for example, if we are writing a function over the rational numbers, or even just the integers, the usual “smaller than” relation does not guarantee our function will terminate; it’s possible to continue choosing smaller and smaller rational numbers or integers forever.

The key idea is exactly that this can’t happen: it’s not possible to have an infinite chain of values where each is related to the previous. That is, there should be no left-infinite chains $\dots \prec y_3 \prec y_2 \prec y_1 \prec x$. Then we are guaranteed that if we keep making recursive calls on values that are related by $\prec$ to the previous value, we will have to stop eventually: after some finite number of calls we will hit a value with nothing else related to it.

A relation $\prec$ with this “no left-infinite chains” property is called well-founded. But how do we encode this idea in Agda?

Accessibility

Instead of thinking negatively (no left-infinite chains), the key is to think positively: all chains to the left of every value are finite. Call a value accessible if all chains leading to it are finite. Another way to say this is that a value is accessible if every value related to it is also accessible:

data Acc (_≺_ : Rel A) : A → Set where
  acc : {x : A} → ((y : A) → y ≺ x → Acc _≺_ y) → Acc _≺_ x

Acc _≺_ x defines what it means for a particular value x to be accessible with respect to a relation $\prec$. There is only one constructor, acc, which requires (y : A) → y ≺ x → Acc _≺_ y—that is, for every value y of type A, if y is related to x, then y is accessible. In other words, x is accessible if and only if every y ≺ x is accessible.

This is definitely tricky to wrap your head around! At this point you may have two objections:

What about base cases? Shouldn’t we have another constructor which says x is accessible if nothing is related to it? Actually, the acc constructor already says that! If nothing is related to x, then (y : A) → y ≺ x → Acc _≺_ y is trivially true: we can easily promise anything we want as the output of a function if we know it can never be called. Every natural number less than zero is a purple flying weasel.
Doesn’t this just run into the same problem as before with left-infinite chains? If we consider the “is one less than” relation on the integers, isn’t $2$ accessible because $1$ is accessible because $0$ is accessible because $-1$ is accessible because … ?

There is something a bit subtle going on here: recursive data types in Agda (unlike Haskell) are interpreted according to a least fixed point semantics. Put in plain terms, the only values of a data type are those which can be built by applications of a finite number of constructors. So in fact, the “no left-infinite chain” condition is foundationally built into the way Agda data types work!

The idea is that we can turn well-founded induction into structural induction by pattern-matching on Acc proofs! Starting with some $x$, any $y \prec x$ has an accessibility proof which is a subterm of the accessibility proof for $x$. This is a bit exotic though: if we pattern-match on the acc for $x$ we get a function that yields an accessibility proof for each $y \prec x$; calling that function produces another accessibility proof, which counts as a structural subterm of the original. This seems a bit strange until you think of a value of type Acc like an big, arbitrarily-branching tree of finite depth; each node contains a function which really just stores all the subtrees. In other words, a function of type (y : A) → y ≺ x → Acc _≺_ y can be thought of as a giant tuple of Acc values, one for each y \prec x.I am not sure exactly how Agda handles this internally, but I assume this is well-trodden ground for designers of proof assistants.

Well-founded induction, defined

Given the definition of accessible elements, we can now give the definition of a well-founded relation: a relation on A is well-founded if every value of type A is accessible.

WellFounded : Rel A → Set
WellFounded {A} _≺_ = (a : A) → Acc _≺_ a

We can now write down the principle of well-founded induction. This is also quite tricky to wrap your brain around, so we’ll go through it slowly. Previously, we were just talking about whether functions terminated or not; but the reason this is important is that a function might be calculating a proof. A function which purports to calculate a proof but sometimes goes into infinite recursion is a charlatan, and not really a proof at all.

So instead of thinking about termination, let’s switch to thinking about proofs. Given a proposition $P$, we want to prove that $P$ holds for every value of type $A$. The idea is that when trying to prove $P(y)$ for a particular $y$, we get to assume that $P(z)$ holds (i.e. we get to make recursive calls) for all $z \prec y$.

Here, then, is the statement of the principle of well-founded induction, with each argument broken out on a separate line so we can explain them as we go.

wf-ind :
  {P : A → Set}

P represents an arbitrary proposition on A; our goal is to show P holds for every value of type A.

  {_≺_ : Rel A} →

An arbitrary relation.

  WellFounded _≺_ →

A proof that ≺ is a well-founded relation.

  ((y : A) → ((z : A) → z ≺ y → P z) → P y) →

This is the trickiest argument to understand. Intuitively, it says “For any y, if we know P z holds for all z ≺ y, then we can show P y also holds.”

  (x : A) → P x

The principle of well-founded induction says that all of this is enough to show that P x holds for all x : A.

So, how do we implement this? If we try something straightforward, as in wf-ind-bad below—just call ind on x, then call wf-ind recursively to fill in the proofs for P z—of course it does not work; Agda cannot tell that this is terminating.As an aside, Agda complains that this definition of wf-ind-bad is not terminating—which makes sense—but it continues to complain even when I include the NON_TERMINATING pragma, which I don’t understand. Perhaps this has been fixed in a more recent version of Agda.

And this makes sense, because we are not even using the fact that the relation is well-founded at all!

module WFIndBad where

  {-# NON_TERMINATING #-}
  wf-ind-bad : {P : A → Set} {_≺_ : Rel A} → WellFounded _≺_ → ((y : A) → ((z : A) → z ≺ y → P z) → P y) → (x : A) → P x
  wf-ind-bad wf ind x = ind x (λ z Rzx → wf-ind-bad wf ind z)

Instead, the right idea is to use the fact that $\prec$ is well-founded to generate an initial proof of accessibility for the input $x$, and then pattern match on accessibility proofs alongside the values as we recurse. Every time we make a recursive call on some $y \prec x$, we can just pattern-match on the accessibility proof for $x$ to get an accessibility proof for $y$, so Agda will be able to see that the whole thing is structurally recursive on the accessibility proofs.

wf-ind {A} {P} {_≺_} wf ind x = go x (wf x)
 where
  go : (x : A) → Acc _≺_ x → P x
  go x (acc f) = ind x (λ z z≺x → go z (f z z≺x))

Less-than is well-founded

Now that we have well-founded induction under our belts, let’s show that the less-than relation on natural numbers is well-founded. This corresponds to what is often called “strong induction”.Incidentally, we could probably have gotten away with directly defining a principle of strong natural number induction, without bothering with the full generality of well-founded induction, but this way is more fun and interesting!

To prove that $<$ is well-founded, we of course must show that every natural number is accessible under $<$. However, if we directly try to prove (m : ℕ) → (Acc _<_) m, we run into a variant of the exact same problem we have been dealing with: to prove that $m$ is accessible we need to know that every $k < m$ is also accessible, but again, we cannot show this directly by recursion/induction, since $k$ may not be a structural subterm of $m$.

What we need is the usual trick for proving strong induction from weak induction: instead of proving that $P(x)$ holds for all $x$, we prove that $(\downarrow P)(x)$ holds for all $x$, where $\downarrow P$ is the “downward closure” of $P$. That is, $(\downarrow P)(x)$ says that $P(x)$ holds for all $y < x$.Note that another way to define $(\downarrow P)(x)$ is that $P(y)$ holds for all $y \sim x$, where $\sim$ is the transitive closure of the predecessor relation. As an advanced exercise, generalize $\downarrow_\prec P$ to be defined relative to the transitive closure of any relation $\prec$, and then prove that $\prec$ is well-founded if and only if its transitive closure is. For more along these lines, see this very cool (but much more abstract) post on well-founded induction by Callan McGill.

↓ : (ℕ → Set) → (ℕ → Set)
↓ P n = (k : ℕ) → (k < n) → P k

Now we can prove, for all natural numbers $m$, that every natural number up to and including $m$ is accessible under the $<$ relation. Zero is accessible because nothing is less than it; everything up to the successor of $m$ is accessible because by induction we know everything up to $m$ is, and anything less than the successor of $m$ must in fact be $\leq m$.

<-acc : (m : ℕ) → ↓ (Acc _<_) m
<-acc zero = λ k ()
<-acc (suc m) zero (sle le) = acc (λ y ())
<-acc (suc m) (suc k) (sle le) = acc (λ y y<sk → <-acc m y (<-≤-trans y<sk le))

Finally, to show that any natural number $n$ is accessible—i.e. that $<$ is well-founded—we can use the fact that all numbers less than the successor of $n$ are accessible, and just project out accessibility for $n$ itself.

<-wf : WellFounded _<_
<-wf n = <-acc (suc n) n (n <suc)

The division algorithm

Finally, we can define the division algorithm, via well-founded induction! The definition is very similar to our first attempt, but we use the principle of well-founded induction with $<$. Note that neither divAlg nor its helper function go is directly recursive. Instead, go takes an induction hypothesis as an argument, which we call instead, providing an extra proof that the subject of the induction hypothesis is in fact less than the original input. wf-ind takes care of the actual recursion.

divAlg : (n d : ℕ) → (0 < d) → DivAlg n d
divAlg n d 0<d = wf-ind {P = λ n → DivAlg n d} <-wf go n
 where
  go : (n : ℕ) → ((n′ : ℕ) → n′ < n → DivAlg n′ d) → DivAlg n d
  go n IH with n decreaseBy? d
  ... | LT n<d = (0 , n) , DM (n +0) n<d
  ... | GE n′ n′+d≡n with IH n′ (+→< 0<d n′+d≡n)
  ... | (q , r) , dm = (suc q , r) , incDivMod n′+d≡n dm

Using the division algorithm, we can also finally decide whether one number divides another: zero divides zero; zero does not divide any successor since that would imply there is some $k$ such that $k$ times zero is nonzero, which is absurd; and if $x$ is a successor, we can apply the division algorithm and check the remainder, applying some previous lemmas that say what zero and nonzero remainders tells us about divisibility.

_∣?_ : (x y : ℕ) → Dec (x ∣ y)
zero ∣? zero = yes (0 , refl)
zero ∣? (suc y) = no λ { (a , eq) → absurd (noConf (trans (sym (*-comm a zero)) eq))}
(suc x) ∣? y with divAlg y (suc x) (sle zle)
... | (q , zero) , dm = yes (mod0→divides y (suc x) dm)
... | (q , suc r) , dm = no (modS→¬divides y (suc x) dm)

Primality testing

To test a number for primality, we are just going to use straightforward, naive trial division. The straightforward way of doing this is by starting at $2$ and counting up—but this is a problem, because when pattern-matching on natural numbers we most naturally count down.

Well, remember—build the evidence you want to pattern-match on! Let’s develop some machinery for counting up instead of down.

Counting up

The problem starts with $\leq$: a proof of $m \leq n$ starts with a base case representing evidence that $0 \leq k$, then every constructor application of sle increments both sides by one. Pattern-matching on a proof of $m \leq n$ thus either reveals that $m = 0$, or that $m' \leq n'$ where $m'$ and $n'$ are the predecessors of $m$ and $n$: in other words, it facilitates counting down, just like matching directly on $m$ would.

However, there is an alternative way to define the $\leq$ relation, which we will call $\leq'$. We can choose reflexivity of $\leq'$ as a base case, that is, $n \leq' n$ for any $n$. We can then decrement the left-hand side every time we apply another constructor. Like so:

data _≤′_ : ℕ → ℕ → Set where
  lerefl : {n : ℕ} → n ≤′ n
  lesuc : {m n : ℕ} → suc m ≤′ n → m ≤′ n

Pattern-matching on a proof of $m \leq' n$ thus facilitates counting up from $m$ to $n$, just like we wanted!

We can also prove a few lemmas about properties of $\leq'$. For example, the two axioms that define the usual $\leq$ can be proved as lemmas.

≤′-suc : {m n : ℕ} → m ≤′ n → suc m ≤′ suc n
≤′-suc lerefl = lerefl
≤′-suc (lesuc m≤′n) = lesuc (≤′-suc m≤′n)

0≤′ : (n : ℕ) → 0 ≤′ n
0≤′ zero = lerefl
0≤′ (suc n) = lesuc (≤′-suc (0≤′ n))

We can also prove that $m \leq n$ implies $m \leq' n$. (The converse is true as well, and can be proved as an easy exercise, but we won’t need it.)

≤→≤′ : {m n : ℕ} → m ≤ n → m ≤′ n
≤→≤′ {n = n} zle = 0≤′ n
≤→≤′ (sle m≤n) = ≤′-suc (≤→≤′ m≤n)

So, we can pattern-match on a proof of $m \leq' n$ to count up from $m$ to $n$, but this isn’t quite good enough: while counting, we won’t remember the relationship of the intermediate values to the original $m$. We would like to be able to count up through some interval, from some starting $a$ to ending $b$, knowing all along the way that the values we count are contained in the interval.

To this end, we can create a data type i ∈[ a ⋯ b ] which represents a stage in counting from $a$ to $b$. The base case is when $i = b$; otherwise i ∈[ a ⋯ b ] when $a \leq i$ and also suc i ∈[ a ⋯ b ].

data _∈[_⋯_] : ℕ → ℕ → ℕ → Set where
  stop : {a b : ℕ} → a ≤ b → b ∈[ a ⋯ b ]
  step : {a i b : ℕ} → a ≤ i → suc i ∈[ a ⋯ b ] → i ∈[ a ⋯ b ]

We can then write a function which “constructs a loop”—that is, starting from a proof of $a \leq' b$, it builds a value of type a ∈[ a ⋯ b ] which represents a reified loop from $a$ to $b$. By pattern-matching on this value we can successively increment from $a$ up to $b$, with the appropriate guarantees along the way.

loop : (a b : ℕ) → (a ≤′ b) → a ∈[ a ⋯ b ]
loop a b a≤′b = mid a a b ≤-refl a≤′b
 where
  mid : (a i b : ℕ) → (a ≤ i) → (i ≤′ b) → i ∈[ a ⋯ b ]
  mid a i b a≤i lerefl = stop a≤i
  mid a i b a≤i (lesuc i≤′b) = step a≤i (mid a (suc i) b (≤-sucr a≤i) i≤′b)

Finally, we need as a simple lemma the fact that if i ∈[ a ⋯ b ] then in fact $i \leq b$.

top : {i a b : ℕ} → i ∈[ a ⋯ b ] → i ≤ b
top (stop _) = ≤-refl
top (step _ s) = ≤-sucl (top s)

Primality testing by trial division

First, a lemma about downward closure: if we know $(\downarrow P)(m)$, and we know $P(m)$, then we know $(\downarrow P)(1 + m)$. In other words, if $P$ holds for everything less than $m$, we can extend it by one by providing a proof that $P$ also holds for $m$.

extend : {P : ℕ → Set} {m : ℕ} → (↓ P) m → P m → (↓ P) (suc m)
extend {m = m} soFar Pm j with (j ≟ m)
... | yes refl = λ _ → Pm
... | no j≢m = λ { (sle j≤m) → soFar j (≤≢→< j≤m j≢m) }

Now we can define primality testing itself, via trial division. We loop from $2$ up to $n$, testing each number to see if it divides $n$, keeping track along the way of the fact that all the numbers less than our current trial divisor do not divide $n$. If the next divisor does divide $n$, we return it as proof that $n$ is composite. If it does not, we extend our accumulating proof of all the numbers that do not divide $n$, and proceed to the next. If we reach $n$, our accumulated proof tells us that none of the numbers less than $n$ divide it, which is proof that $n$ is prime.

prime? : (n : ℕ) → (2 ≤ n) → Prime n ⊎ Composite n
prime? n 2≤n = trialDiv (loop 2 n (≤→≤′ 2≤n)) noDivisorsUpTo2
 where
  NoDivisorsUpTo : ℕ → Set
  NoDivisorsUpTo = ↓ (λ # → (2 ≤ #) → ¬ (# ∣ n))

  noDivisorsUpTo2 : NoDivisorsUpTo 2
  noDivisorsUpTo2 (suc zero) _ (sle ()) _
  noDivisorsUpTo2 (suc (suc j)) (sle (sle ())) _ _

  trialDiv : {m : ℕ} → m ∈[ 2 ⋯ n ] → NoDivisorsUpTo m → Prime n ⊎ Composite n
  trialDiv (stop 2≤n) soFar = inj₁ (2≤n , soFar)
  trialDiv {m} (step 2≤m next) soFar with m ∣? n
  ... | yes m∣n = inj₂ (m , 2≤m , top next , m∣n)
  ... | no pf = trialDiv next (extend soFar (λ _ → pf))

Lists

Before we are able to state the Fundamental Theorem of Arithmetic, we need to build up a data type for lists, along with some standard list manipulation functions. First, we define the type of lists and the standard foldr function.

data List (A : Set) : Set where
  [] : List A
  _∷_ : A → List A → List A

foldr : (A → B → B) → B → List A → B
foldr _&_ z [] = z
foldr _&_ z (x ∷ xs) = x & foldr _&_ z xs

Now we can define concatenation and product via foldr.

_++_ : List A → List A → List A
xs ++ ys = foldr (_∷_) ys xs

product : List ℕ → ℕ
product = foldr _*_ 1

We will need All, which expresses that some predicate holds of all the elements of a list. In fact, All is manifestly an instance of foldr as well, but we would need a universe-polymorphic version of foldr for that, so we just write it manually.

All : (P : A → Set) → List A → Set
All P [] = ⊤
All P (x ∷ xs) = P x × All P xs

Now, we just need a couple lemmas about concatenation: first, that if P holds for all the elements in xs and all the elements in ys, then it holds for all the elements in xs ++ ys; and second, that product distributes over concatenation (i.e. it is a homomorphism from the monoid of lists under concatenation to the monoid of natural numbers under multiplication).

All-++ : {P : A → Set} {xs ys : List A} → All P xs → All P ys → All P (xs ++ ys)
All-++ {xs = []} Pxs Pys = Pys
All-++ {xs = _ ∷ _} (Px , Pxs) Pys = Px , All-++ Pxs Pys

product-++ : (xs ys : List ℕ) → product (xs ++ ys) ≡ product xs * product ys
product-++ [] ys = sym (_ +0)
product-++ (x ∷ xs) ys = trans (x *_ $≡ product-++ xs ys) (sym (*-assoc x (product xs) (product ys)))

The Fundamental Theorem of Arithmetic

Finally, we can put all the pieces together to state and prove (one half of) the Fundamental Theorem of Arithmetic! FTA n says that for some positive integer n, we can find a list of natural numbers which are all prime, and whose product is n.

FTA : ℕ → Set
FTA n = Σ (List ℕ) (λ ps → All Prime ps × product ps ≡ n)

To prove that this holds for all positive integers, we can again use well-founded induction: in the base case, if $n = 1$, the empty list suffices. Otherwise, we can decide whether $n$ is prime. If so, the singleton list containing $n$ fits the bill. Otherwise, $n = ab$ where $a$ and $b$ are both nontrivial divisors of $n$; by the induction hypothesis, both can be factored into primes, and the list we want for $n$ is simply the concatenation of the factorizations for $a$ and $b$.

fta : (n : ℕ) → (0 < n) → FTA n
fta n = wf-ind {P = (λ n → (0 < n) → FTA n)} <-wf go n
 where
  go : (n : ℕ) → ((n′ : ℕ) → n′ < n → 0 < n′ → FTA n′) → 0 < n → FTA n
  go (suc zero) IH 0<n = [] , (tt , refl)
  go (suc (suc n)) IH 0<n with prime? (suc (suc n)) (sle (sle zle))
  ... | inj₁ P = (suc (suc n) ∷ []) , ((P , tt) , (suc $≡ (suc $≡ (n *1))))
  ... | inj₂ C with factorsOf _ C
  ... | ((a , sle _ , a<n , _) , (b , sle _ , b<n , _)) , ab≡n
      with IH a a<n (sle zle)
         | IH b b<n (sle zle)
  ... | ps₁ , Pps₁ , prod₁ | ps₂ , Pps₂ , prod₂ = (ps₁ ++ ps₂) , (All-++ Pps₁ Pps₂) ,
    begin
      product (ps₁ ++ ps₂)      ≡[ product-++ ps₁ ps₂ ⟩≡
      product ps₁ * product ps₂ ≡[ _*_ $≡ prod₁ ≡$≡ prod₂ ⟩≡
      a * b                     ≡[ ab≡n ⟩≡
      suc (suc n)               ∎

Further Directions

That concludes our tour of the Fundamental Theorem of Arithmetic in Agda! If you’ve worked through the whole thing and completed the proofs mostly on your own, congratulations! If you want more practice, there are a lot of directions you could take this:

Doing trial division all the way up to $n$ is silly; we can stop when we get to $\sqrt n$. I think this would make for a nice exercise (in fact, Taneb’s version in the Agda stdlib does this).
Define “$d$ is a proper divisor of $n$” to mean that that $d \mid n$ and $2 \leq d < n$, then show that the “is a proper divisor of” relation is well-founded, and prove fta via well-founded induction on that relation instead. This might streamline some parts of the proof; I’m not sure.
The other half of the FTA says that the prime factorization is unique up to permutation. To prove this, one has to define what it means for one list to be a permutation of another, and show that if there are two different prime factorizations then one must be a permutation of the other (if $p$ is a prime from the first factorization, then it divides the other factorization as well, which means it must be equal to one of the primes in the other factorization). I may write up this proof in a follow-up post.

Philip Wadler: Crank GPT

noreply@blogger.com (Philip Wadler) — Wed, 24 Jun 2026 20:01:41 +0000

Not a crank project! Spotted via Robin Sloan.

GHC Developer Blog: GHC 9.12.5-rc2 is now available

Wed, 24 Jun 2026 00:00:00 +0000

GHC 9.12.5-rc2 is now available

mangoiv - 2026-06-24

The GHC developers are very pleased to announce the availability of the second release candidate for GHC 9.12.5, ghc-9.12.5-rc2. The first release candidate did not receive an announcement since promptly after publishing it, an urgent issue with distribution of the process library on macos was discovered. This is now fixed. Binary distributions, source distributions, and documentation are available at downloads.haskell.org and via GHCup.

GHC 9.12.5 is a bug-fix release fixing many issues of a variety of severities and scopes, including:

Implement version 2 of the ghc semaphore protocol for GHC’s -jsem jobserver on Linux and other POSIX platforms (#25087, #27253)
several improvements to the pattern match checker (#25926, #27124)
several improvements to the demand analyser (#27261, #27106, #26416)
several fixes regarding the interaction of ticks and coercions (#27121, #26929, #26642, #26693)
several fixes for blackholes (#27261)

… and many more

A full accounting of these fixes can be found in the release notes. As always, GHC’s release status, including planned future releases, can be found on the GHC Wiki status.

This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 8 July 2026.

GHC development is sponsored by:

As always, do give this release a try and open a ticket if you see anything amiss.

Gabriella Gonzalez: Record type inference for dummies

Tue, 23 Jun 2026 00:00:00 +0000

Gentle tour of type inference for records

Well-Typed.Com: Haskell ecosystem activities report: Marchâ€“May 2026

Fri, 19 Jun 2026 00:00:00 +0000

This is the thirty-first edition of our Haskell ecosystem activities report, which describes the work Well-Typed are doing on GHC, Cabal, HLS and other parts of the core Haskell toolchain. The current edition covers roughly the months of March 2026 to May 2026.

You can find the previous editions collected under the haskell-ecosystem-report tag.

Sponsorship

We offer Haskell Ecosystem Support Packages to provide commercial users with support from Well-Typed’s experts while investing in the Haskell community and its technical ecosystem including through the work described in this report. To find out more, read our announcement of these packages in partnership with the Haskell Foundation. We need funding to continue this essential maintenance work!

Many thanks to our Haskell Ecosystem Supporters: Standard Chartered, Channable and QBayLogic, as well as to our other clients who also contribute to making this work possible: Anduril, Juspay and Mercury; and to the HLS Open Collective for supporting HLS release management.

Highlights

Reinstallable base

Rodrigo and Wolfgang have continued working to disentangle base from GHC, with the ultimate goal of being able to use different versions of base with a single GHC version. This is all part of a long-term project to make GHC upgrades easier, documented in the reinstallable-base repo, and recently described in an excellent haskell.org blog article by Simon Peyton Jones. Simon, Rodrigo and Wolfgang are working together to rethink GHC’s treatment of “known-key names” so base will be much less tightly coupled to ghc-internal (!15899).

One big milestone was making the current base buildable both with GHC 9.14 (!16070) and with the upcoming GHC 10.0 (!16035).

Various other pieces of technical groundwork were required:

moving most of the System.IO implementation into base (!15694),
similarly moving Text.Read (!15693, !15777),
making various SafeHaskell-related changes (CLC #408, !16034).

Wolfgang also opened several CLC proposals identifying key areas that require further work:

the deprecation of unstable base modules (CLC #392), and
working towards making bytestring and text not depend on internal I/O machinery (CLC #410).

Semaphores and `-jsem`

The implementation of semaphores used by cabal-install and GHC to coordinate concurrency suffered from a serious issue when GHC and cabal-install were linked against different libc implementations (#25087).

Zubin remedied this issue with a new semaphore implementation on top of Unix domain sockets (!8), described in GHC proposal #673. GHC (!15729) and cabal-install (#11628) were then switched to this new protocol version.

As part of this work, Zubin also identified some deficiencies in the semantics of interruptible FFI (#27110).

Cabal modernisation

Sam worked to modernise the architecture of cabal-install by making it directly call the Cabal library to build packages (#11703). This unlocked the performance optimisations described in a recent blog post (#11767, #11768), achieving speed-ups of around 10-15% in certain situations.

In the long term, we would like to move towards Cabal having a fine-grained build graph across the whole project, rather than using a component-level build graph and relying on GHC to orchestrate the compilation of all the modules in a component/package. This will unlock more parallelism and other developer experience improvements.

Sam also implemented many improvements to build-type: Hooks, the modern replacement for build-type: Custom:

an improved API for SetupHooks authors (#11772),
better documentation (#11771),
improved recompilation checking for pre-build rules (#11731),
support for generating non-Haskell files in pre-build rules (#11573).

Tobias chimed in by adding support for recursive globs in file monitoring, which is useful for SetupHooks (#11658).

Windows DLL support

Duncan, with the help of David, embarked on the project of adding proper dynamic linking support to GHC on Windows. While this is still work-in-progress, several important steps have already been taken:

extending Cmm syntax to support symbols from external DSOs/DLLs (!15135),
solving the recursive DLL dependency between the RTS and ghc-internal (!15907),
making GHC use __attribute__((dllimport)) for external symbol declarations (!15914),
updating Hadrian to create individual .def files per ghc-internal DLL (!16082).

Critical `process` issue on macOS

Magnus diagnosed a critical issue with process on macOS (#27144, #356), implementing a fix in #363. As part of this work, he discovered an issue with several uploaded versions of process (#365) which was resolved by coordinating with the process maintainers.

GHC

Releases

Keeping all of GHC’s active release branches in good shape is a demanding, largely behind-the-scenes effort. Each release requires triaging and backporting a steady stream of bugfixes, with patches that often don’t cleanly apply and require careful reworking. Information about upcoming releases is available on the GHC release status page.

GHC currently has four (!) active branches. Zubin worked towards the 10.0 release as well as on 9.14.2; Magnus prepared 9.12.5, and Andreas took on 9.10.4.

Frontend

Rodrigo bumped the default language edition to GHC2024 (#26039, !14420). Starting from GHC 10.0, code without an explicit language edition will default to GHC2024. Compared to GHC2021, this adds the extensions DataKinds, DerivingStrategies, DisambiguateRecordFields, ExplicitNamespaces, GADTs, MonoLocalBinds, LambdaCase and RoleAnnotations.
Magnus fixed the documentation of getSizeofMutableByteArray# (!16065).
Sam fixed a loop with -XDeepSubsumption on GHC 9.14 (#26823, !15604).
Wolfgang made several performance improvements to the driver, allowing downsweep to use existing module graph nodes (!16028), introducing a cache for hole modules (!15888), and storing home unit dependencies as sets (!15849).
Hannes made several performance improvements to ghc-pkg, speeding up its closure computation (!16062) and migrating it to use OsPath (!15584).
Andreas modularised the GHC.Driver.Main module (!15940), as that single module had become quite unwieldy.
Following on from previous work allowing typechecker plugins to run in the pattern match checker (!14797), Sam made sure that plugins are only initialised once per module (!15485), fixing the regression reported in #26839.
Rodrigo provided a standalone reproducer for the simplifier slowness reported in #26989, which allowed Simon Peyton Jones to diagnose and fix this quadratic behaviour (!15725).
Sam investigated the type family performance regressions reported in #26426, identifying two key patches that had accidentally fixed the regression and recording these findings in Notes (!16113).
Andreas identified that a patch to use Generics within GHC significantly regressed compile times (#27191). The offending patch was reverted for the time being, and the coding style Wiki page was updated to document this unfortunate limitation.

Backend

Sam finished up work by Matthew Craven to improve the representation of floating point literals in GHC, fixing several issues with the treatment of negative zero and NaN values (!15528). This brings GHC much closer to proper IEEE 754 floating point compliance.
Andreas discovered a bug with AArch64 profiled dynamic builds of GHC and concluded that it was a bug in gcc/binutils (#26994).
Sam fixed a crash in Core Prep caused by invalid profiling tick occurrences (#27182, !16003).
Sam investigated a crash in mkDupableContWithDmds, and worked with Simon Peyton Jones to land a fix (#27261, !16084).
Sam fixed several bugs in the implementation of the hsExprType function (#26910, !15772).
Zubin fixed the typing of void pointer chains in capi FFI calls to avoid -Wincompatible-pointer-type errors by the C compiler (#26852, !15547).
Sam helped first-time contributor Avery Parker land his AmeriHac contribution to add constant folding for SIMD vector operations (!15512).
Sam reviewed several patches to the AArch64 native code generator by Ian Duncan, in the process uncovering a cluster of latent correctness bugs:
- !15620 fixed a bug in “shift right” using a logical shift instead of an arithmetic shift (#26979). A separate register clobbering bug was identified and fixed.
- !15619 fixed sign extension at 32-bit width (#26978). A separate bug with the overflow bit was identified and fixed (#27047). Another register clobbering bug was found and fixed separately (#27046, !16031).
Sam fixed a recalcitrant “failed to detect OverLit” crash in coreExprToPmLit (!15895, #27124, #25926).
Magnus and Sam investigated the GHC panic reported in #27227, which was narrowed down to Cabal bug #7684, and subsequently fixed (#11791).

ghci & bytecode

Work continued on making the bytecode interpreter, which underpins GHCi as well as the debugger, more capable and memory efficient.

Hannes introduced the -fimport-loaded-target ghci flag to fix a regression with the :add command relating to support for multiple home units (!15533, #26866).
Hannes fixed a regression in the behaviour of :load (#27202, !15980).
Hannes added support for hpc in the bytecode interpreter (#27036, !15843).
Rodrigo added support for static constructors in the bytecode interpreter, also fixing its treatment of unlifted values (#25636, !15221).
Hannes improved the memory usage of the bytecode interpreter by recording only a LinkableUsage instead of Linkable in LoaderState (#26500, #27018, !15689).

RTS

Duncan consolidated the ticker implementations to a single one on POSIX (!15781), removing signal-based ticker implementations (!15757, !16014) which presented a number of disadvantages (described in #27073).
David resurrected an old MR improving the documentation of the allocator (!3812).
Andreas added missing profiling headers for origin_thunk frames (!15665).
Duncan identified some incorrect STOP_THREAD status codes in ghc-events (#130).

Build system

David made several improvements to GHC’s build system and Hadrian, in relation to his work on Windows DLL support:
- a fix for Unix paths in ACLOCAL_PATH (!16112),
- proper LLVM program versioning logic (!16025),
- work on response files to avoid MAX_PATH issues on Windows (!15891, !16120).
Andreas fixed an issue with --target in the configure script (!15649).
Zubin stopped Hadrian from including package hashes in Haddock directory names, as this was causing many broken links when browsing Haddocks (#26635, !15475).

GHC contribution experience

Magnus overhauled the MR template to be more helpful for new contributors (!15943, #27165).
Many team members provided reviews and helped land contributions from others, as described elsewhere in this report.

CI and tests

Magnus has been doing significant work on the gitlab.haskell.org instance and CI infrastructure to improve robustness of CI, deal with spam and manage the server load imposed by AI crawlers.
Magnus changed the Darwin CI to clone rather than copy when creating the Cabal cache (!15683).
Sam added a vendored mini-QuickCheck component for use in GHC’s testsuite, fixing some bugs in the previous implementation used in the foundation primops testsuite (!15893, #25969, #25990).

Haskell Language Server

Zubin prepared release 2.14.0 of the Haskell Language Server (#4897).
Hannes reviewed many HLS PRs from contributors:
- #4958 adding a code action to delete unused bindings,
- #4913 improving the handling of hs-boot files,
- #4915 updating the splice plugin,
- #4917 preserving qualified field names when expanding record inlay hints,
- #4902 excluding internal superclass names in class placeholders,
- #4886 cancelling outstanding threads when closing the SQLite connection,
- #4867 improving HLS’s response for prepareRename,
- #4865 migrating the Stackage build to use GitHub actions,
- #4854 fixing a redundant hash in the ghcide cache path.
Hannes released version 0.19.0 of hie-bios (#506).
Sam fixed a hie-bios regression in which the local build directory would get overwritten, leading to cache trashing (#501, #503).

Haskell syntax highlighting

Sam fixed a large number of bugs in the language-haskell VS Code syntax highlighting extension.

Haskell Debugger

Rodrigo continued to lead development of the Haskell Debugger (hdb), an interactive step-through debugger for Haskell, with contributions from Andrea and Hannes. Built on top of the bytecode interpreter, it implements the Debug Adapter Protocol, allowing debugging of Haskell programs directly in the editor. We:

added a new RTS message to GHC allowing a thread’s flags (TSO flags) to be set or unset (!15831, #27131), which is needed to safely implement features like pausing, or toggling step-out/step-in per thread;
arranged for hdb to run the debuggee directly in the terminal when using the external interpreter (#260);
added support for custom external interpreter commands to GHC (!15676), making use of them rather than parsing heap terms (#222);
fixed a bug where forcing a thunk would invalidate stack frames on all threads rather than just the right one (#292), and fixed breakpoints being overwritten by looking for active breaks in the correct ModBreaks (#298);
refactored the home-unit session initialisation (#279).

Andrea made various quality-of-life improvements to the debugger:

allowing imports at the REPL (#229);
bringing interactive imports back into scope after resuming execution (#275);
inheriting the entry file’s language extensions (#230);
adding LogMessage support to implement log points (#223);
sharing a single HDB+GHC session for use with HLS (#308).

Runtime observability

`ghc-debug`

Hannes performed various maintenance tasks on ghc-debug, a key tool for out-of-process heap analysis of Haskell programs:

released version 0.8.0.0 (!88),
bumped version bounds (!91),
fixed FreeBSD support (!89),
landed an old MR by Teo Camarasu, adding support for the non-moving GC (!10).

`eventlog-live`, `eventlog-socket`

Wen continued to develop eventlog-live, which allows GHC’s eventlog to be monitored live as a program runs. Highlights of the changes to eventlog-live:

support for receiving eventlog input over TCP (#154, #155),
improved profiling support with cost-centre profiles (#134) and ghc-stack-profiler profiles (#131),
integration with the RTS control server (#139, #122, #126),
a new demo showing eventlog-live monitoring GHC itself (#138, #148),
support for GHC 9.12 (#136).

This also included a litany of improvements to the underlying eventlog-socket library:

lifecycle hooks (#63),
command registration (#45),
support for startProfTimer and stopProfTimer (#65),
allow building with hsc2hs in cross-compilation mode (#64).

Finally, Wen also landed several supporting changes in GHC itself:

fixed a race condition in the RTS between flushEventLog and starting/stopping event logging (!15750),
added a new -lI eventlog flag to emit IPE events (!16004),
added support for dynamically changing trace flags (!15936).

`ghc-stack-profiler`

Hannes continued maintaining ghc-stack-profiler, a profiler that relies on stack annotations rather than heavier profiling mechanisms:

released version 0.2.0.0 (#24);
made the profiler more robust, ensuring it never crashes on decoding errors (#12) and backporting a fix for stack-decoding segmentation faults from GHC HEAD (#20);
integrated the profiler with eventlog-socket, adding support for its lifecycle hooks (#19) and an eventlog-socket test suite (#25);
improved thread management by using async (#10) and exposing stopStackProfilerThread (#11).

`IHaskell`

Sam added Windows support to IHaskell, a library that provides Haskell integration for Jupyter notebooks (#1595).

`stm` library

Magnus performed some important maintenance tasks on the stm library, adding missing compiler versions to CI (#98) and fixing a slow test (#97).

Tweag I/O: Sheaves in Haskell

Thu, 18 Jun 2026 00:00:00 +0000

I recently found a way to represent sheaves in Haskell. It was a fun couple of weeks of head-scratching. But as much as I wanted it to, the code in my demonstration repo doesn’t speak for itself. So I’m writing this blog post to share my newfound understanding. In this post I’ll be assuming a pretty solid knowledge of category theory (but not of sheaves, which I’ll be explaining). If you aren’t, wait until my next post which will give a more practical introduction to sheaves.

I don’t think it’s necessary to use Haskell for this. Other functional programming languages should work as well, but Haskell certainly makes some things easier as types get a bit dependent eventually. Of course, it would be even easier in a true dependently typed language, but the whole point was to avoid needing that level of sophistication.

As a general warning: all of this is about translating well-known mathematical concepts into Haskell. While doing so, I have to use a lot of approximations, as Haskell doesn’t have, say, a notion of equality. I will generally not even mention any conditions that I’m supposed to prove to properly align with the mathematical definitions, and only focus on the operational aspects. I’ll try to leave enough breadcrumbs to fill in the gaps for those of you who would want to.

First, presheaves

I’ll start by giving a concrete instance of sheaves, which makes the definition surprisingly transparent. Later I’ll be expanding that to the general notion of sheaves.

Let’s give ourselves a category of arithmetic expressions, or rather, arithmetic functions. It’s got just enough material to illustrate the point.

type Ty :: Type
data Ty = TInt | TBool | TUnit | TProd Ty Ty

type Expr :: Ty -> Ty -> Type
data Expr i j where
  Id :: Expr i i
  Add :: Expr i TInt -> Expr i TInt -> Expr i TInt
  Sub :: Expr i TInt -> Expr i TInt -> Expr i TInt
  Mult :: Expr i TInt -> Expr i TInt -> Expr i TInt
  Unit :: Expr i TUnit
  IsZero :: Expr i TInt -> Expr i TBool
  IfThenElse :: Expr i TBool -> Expr i j -> Expr i j -> Expr i j

compose :: Expr i j -> Expr j k -> Expr i k
compose e Id = e
compose e (Add l r) = Add (compose e l) (compose e r)
compose e (Sub l r) = Sub (compose e l) (compose e r)
compose e (Mult l r) = Mult (compose e l) (compose e r)
compose e (IsZero n) = IsZero (compose e n)
compose e Unit = Unit
compose e (IfThenElse b t f) = IfThenElse (compose e b) (compose e t) (compose e f)

Now, consider the category of presheaves over Expr:

type Presheaf :: (Ty -> Type) -> Constraint
class Presheaf p where
  pb :: forall i j. Expr i j -> p j -> p i

(I named the presheaves’ restriction pb, for “pullback”, because we’re going to be writing it quite a lot.)

The category of presheaves (with natural transformations forall i. p i -> q i as morphisms) is a Cartesian closed category (and then some) which contains the Expr category as a full subcategory, via the Yoneda embedding

type Y :: Ty -> (Ty -> Type)
newtype Y j i = MkY (Expr i j)

instance Presheaf (Y i) where
  pb f (MkY g) = MkY (g `compose` f)

Therefore we can think of the category of presheaves as a completion of Expr with a bunch of extra structure. And the problem that we will want to solve is that presheaves actually add too much structure. This manifests in the impossibility of interpreting IfThenElse. Or, rather, the Yoneda embedding lets us build a presheaf

ifThenElse :: Y TBool i -> Y j i -> Y j i -> Y j i

But this isn’t the usual type of ifThenElse, we want instead

ifThenElse :: (Presheaf p) => forall i. Y Bool i -> p i -> p i -> p i

Sheaves, concretely

Unfortunately, we can’t define such an ifThenElse function. This is because Y TBool isn’t a coproduct in the category of presheaves. Presheaves create coproducts (and in fact all colimits) freely.

What we can do, however, is define a new type class, and we can even define it in the most on-the-nose way possible (because nobody is stopping us).

class Presheaf p => Sheaf p where
  glueIfThenElse :: forall i. Expr i TBool -> p i -> p i -> p i

ifThenElse :: Sheaf p => forall i. Y TBool i -> p i -> p i -> p i
ifThenElse (MkY e) = glueIfThenElse e

This is almost insultingly straightforward, but I swear this is a mere specialisation of the general definition of sheaves, only slightly simplified from the definition seen in textbooks.

Now, of course, sheaves support ifThenElse as we wanted, but the truly astounding thing is that the theory of sheaves tells us that the category of sheaves (and natural transformations forall i. p i -> q i) also has all the structure we need from the category of presheaves. In particular it’s Cartesian closed. Let’s demonstrate this next.

Closed Cartesianness

Products of sheaves are simply Haskell’s product applied fibrewise, same as with presheaves:

type (×) :: (Ty -> Type) -> (Ty -> Type) -> (Ty -> Type)
newtype (p × q) i = MkProd (p i, q i)

instance (Presheaf p, Presheaf q) => Presheaf (p × q) where
  pb f (MkProd (x, y)) = MkProd (pb f x, pb f y)

instance (Sheaf p, Sheaf q) => Sheaf (p × q) where
  glueIfThenElse b (MkProd (tp, tq)) (MkProd (fp, fq)) =
    MkProd (glueIfThenElse b tp fp, glueIfThenElse b tq fq)

Exponential objects are more complicated. If you’ve never seen exponentials of presheaves before, you can think of the type in terms of variance: because forall i. p i -> q i is contravariant in p, we can’t implement pb for natural transformation directly. So we freely adjoin the presheaf structure. Here again, the construction is the same for presheaves and sheaves.

type PFun :: (Ty -> Type) -> (Ty -> Type) -> (Ty -> Type)
newtype PFun p q i = MkPFun (forall k. Expr k i -> p k -> q k)

instance (Presheaf p, Presheaf q) => Presheaf (PFun p q) where
  pb f (MkPFun g) = MkPFun $ \k x -> g (compose k f) x

instance (Presheaf p, Sheaf q) => Sheaf (PFun p q) where
  -- This is not a typo, `p` only needs to be a presheaf.
  -- It's occasionally useful.
  glueIfThenElse b (MkPFun ft) (MkPFun ff) = MkPFun $
    \k x -> glueIfThenElse (k `compose` b) (ft k x) (ff k x)

I found that the twist in the definition of exponentials is the source of much of the difficulties in working with sheaves. For instance, this is why we need IfThenElse and glueIfThenElse rather than this more typical way of expressing that TBool is a coproduct of Unit and Unit:

cocone :: Expr TUnit i -> Expr TUnit i -> Expr TBool i
cocone t f = IfThenElse Id (Unit `compose` t) (Unit `compose` f)

glueCocone :: p TUnit -> p TUnit -> p TBool
glueCocone t f = glueIfThenElse Id (pb Unit t) (pb Unit f)

It turns out that IfThenElse is, in fact, strictly stronger than cocone in general. I started the project believing them to be equivalent, but they aren’t in general. They are equivalent in a Cartesian closed category (among other things) though, but Expr isn’t Cartesian closed. Textbooks also have a version of glueCocone, specifically that sheaves must verify that p TBool must be isomorphic to a pair p TUnit. Realising that this condition wasn’t sufficient to prove that PFun p q was a sheaf took me a while; and this is how, dear reader, one loses nights of sleep.

Yoneda embeddings as sheaves

Another thing, with our definition of sheaves, is that the Yoneda embeddings of objects Ty are sheaves. This won’t always be the case for the general notion of sheaves below, though.

instance Sheaf (Y i) where
  glueIfThenElse b (MkY t) (MkY f) = MkY $ IfThenElse b t f

Coproducts of sheaves

The category of sheaves also has coproducts, but they aren’t the same as that of presheaves. Coproducts of presheaves are defined fibrewise like products, but as we’ve been saying this is “too free”, in that it creates a coproduct for TUnit and TUnit which is distinct from TBool.

Fortunately, there’s a technical device which makes defining coproducts of sheaves easy: the free sheaf construction, also known as sheafification. It turns out that we can construct a free sheaf out of any presheaf, and the way you do that is to simply store all the uses of glueIfThenElse instead of running them (much like PFun stores all the uses of pb instead of running them):

data Sheafify p where
  Ret :: p i -> Sheafify p i
  ShIfThenElse :: Expr i TBool -> Sheafify p i -> Sheafify p i -> Sheafify p i

instance Presheaf p => Sheaf (Sheafify p) where
  glueIfThenElse = ShIfThenElse

instance Presheaf p => Presheaf (Sheafify p) where
  pb g (Ret x) = Ret (pf g x)
  pb g (ShIfThenElse b t f) = ShIfThenElse (pb g b) (pb g t) (pb g f)

The coproduct of two sheaves is simply the sheafification of their coproduct as presheaves.

newtype PSum p q i = MkPSum (Either (p i) (q i))

instance (Presheaf p, Presheaf q) => Presheaf (PSum p q) where
  pb f (PSum (Left x)) = PSum (Left (pb f x))
  pb f (PSum (Right y)) = PSum (Right (pb f y))

type ShSum p q = Sheafify (PSum p q)
-- Therefore:
-- instance (Sheaf p, Sheaf q) => Sheaf (ShSum p q))

You can also define recursive data types like lists (in categorical terms, polynomial endofunctors have initial algebras), you just have to make sure to wrap all the recursive calls with Sheafify. The easiest way is to inline Sheafify like so:

data ShList p i where
  ShNil :: ShList p i
  ShCons :: p i -> ShList p i -> ShList p i
  ListIfThenElse :: Expr i TBool -> ShList p i -> ShList p i -> ShList p i

Sheaves, generally

Now we have the general idea set up. Let’s tackle the general notion of sheaves. First we can get rid of Expr, and use an arbitrary category as a base.

-- The `Category` class from base.
type Category :: forall {k}. (k -> k -> Type) -> Constraint
class Category hom where
  id :: hom a a
  (.) :: hom b c -> hom a b -> hom a c

Presheaves readily generalise to arbitrary categories

type Presheaf :: forall {k}. (k -> k -> Type) -> (k -> Type) -> Constraint
class Presheaf hom p where
  pb :: hom a b -> p b -> p a

Topology, sites

We will need an extra piece of data in order to define sheaves, called a Grothendieck topology (I’ll just be saying “topology”). This will be the part that lets us choose which objects of the base category are to be colimits in the category of sheaves.

Before I show how we can represent topologies in Haskell, let us make a small detour and examine the textbook definition of sheaves (and reverting to mathematical notation for a moment). First a new notion: a sieve on an object $a$ is a set of arrows with codomain $a$ closed by precomposition. That is a set $S$ , such that for any $\stackrel{f}{\longrightarrow} a)\in S</annotation></semantics>$ and any arrow $\stackrel{g}{\longrightarrow} x)</annotation></semantics>$ , we also have $\stackrel{g}{\longrightarrow} x \stackrel{f}{\longrightarrow} a)\in S</annotation></semantics>$ . A topology is a set of such sieves (subject to some axioms). Sieves in a topology are called covering sieves.

Let $P$ be a presheaf. A matching family in $P$ , for a covering sieve $S$ on $a$ , is a function $m$ mapping each $\stackrel{f}{\longrightarrow} a)\in S</annotation></semantics>$ to $encoding="application/x-tex">m_f ∈ P(x)</annotation></semantics>$ , such that $encoding="application/x-tex">m_{f . g} = \mathsf{pb}(g) (m_f)</annotation></semantics>$ . Then, $P$ is a sheaf if for every such matching family $m$ , there is a unique $encoding="application/x-tex">\mathsf{glue}(m) \in P(a)</annotation></semantics>$ such that $encoding="application/x-tex">m_f = \mathsf{pb}(f) (\mathsf{glue}(m))</annotation></semantics>$ for all $f \in S$ .

Now, this is an extraordinarily compact definition. It achieves a lot in just a handful of axioms. But it’s also a very wasteful definition. The definition of sieves requires that all the $\stackrel{g}{\longrightarrow} x \stackrel{f}{\longrightarrow} a)\in S</annotation></semantics>$ are arguments of $m$ , but at the same time that $encoding="application/x-tex">m_{f . g}</annotation></semantics>$ is determined by $encoding="application/x-tex">m_f</annotation></semantics>$ .

This is very unsatisfactory from a functional programming perspective, as we like to make illegal things unrepresentable, but the mathematical definition gives us infinitely many ways to represent illegal states. Besides, having many irrelevant values to take into account adds unwanted noise to our programs.

Even if you are fine with those issues, there’s a bigger problem. The implementation of gluing for exponentials (much for the same reason as exponentials needing the full IfThenElse rather than merely cocone) necessarily involves a sieve, called the pullback sieve $encoding="application/x-tex">f^*S</annotation></semantics>$ where ( $\stackrel{f}{\longrightarrow} a)</annotation></semantics>$ is an arrow and $S$ is a sieve on $a$ ; $encoding="application/x-tex">f^*S</annotation></semantics>$ is, then, a sieve on $b$ . And this is too much dependent typing for even Haskell. I’ve tried to make it work but couldn’t.

Which leads us to our first simplification: we don’t need covering sieves, we can consider arbitrary covering families of arrows (the corresponding covering sieve is the sieve generated by those arrows, but it’ll only exist in our head). Our second simplification is that we don’t even need covering families to be families of arrows: arbitrary types will do. This will remove most of the obstacles, and the pullback sieve won’t show up at all.

In ordinary mathematics, a topology is a set of sets. The natural way to represent this in types is as a type indexed by another type, which yields our definition of topology, or rather of a site: a category equipped with a topology.

type Site :: forall {k}. (k -> k -> Type) -> Constraint
class Category hom => Site hom where
  data Cover hom :: k -> Type
  data Gen hom :: Cover hom a -> k -> Type

Where Cover hom a is the type of covering families of a (typically, Cover hom a is simply an enum of names), and Gen hom c is the type of elements of the covering family c (which we think of as generating a covering sieve, hence the name).

Sheaves on a site

Now sheaves are given by the following type class:

class (Site hom, Presheaf hom p) => Sheaf hom p where
  glue :: forall {a} (c :: Cover hom a) b. hom b a -> (forall x. Gen hom c x -> p (x × b)) -> p b

(I’ve cheated a little and assumed that the underlying category is Cartesian; we can get rid of this hypothesis by replacing p (k × b) with the equivalent, but considerably more heavyweight, PFun (Y x) p b)

This definition includes one trick that I haven’t described yet: with a cover c :: Cover hom a instead of gluing only at type p a, we need to be able to glue at type p b for any arrow f :: hom b a. This is how we avoid having to talk about a pullback sieve. And this also seems to be why generators don’t need to be actual arrows.

To elucidate this definition, let’s see how to instantiate it to Expr¹

instance Site Expr where
  data instance Cover Expr i where
    BoolCover :: Cover Expr TBool

  data instance Gen Expr c k where
    TrueCovers :: Gen Expr BoolCover TUnit
    FalseCovers :: Gen Expr BoolCover TUnit

glueIfThenElse :: (Sheaf Expr p) => Expr i TBool -> p i -> p i -> p i
glueIfThenElse b t f = glue @_ @BoolCover b $ \g -> case g of
  TrueCovers -> pb snd t
  FalseCovers -> pb snd f

To show a bigger example, one that makes use of the x parameter in p (x × b) (so far we’ve simply ignored x, since it’s always been equal to Bool), let’s extend the arithmetic expressions with a sum type:

data SumTy = … | TSum a b

data SumExpr i j where
  … -- Like Expr
  Left :: SumExpr i j -> SumExpr i (TSum j k)
  Right :: SumExpr i j -> SumExpr i (TSum k j)
  Case :: SumExpr i (TSum k j) -> SumExpr (k × i) l -> SumExpr (j × i) l -> SumExpr i l

In order to be able to pattern match on sums in the category of sheaves, we will have to add a cover for TSum. As the type of Case suggests, we will use the x parameter to pass the value contained in Left or Right.

instance Site SumExpr where
  data instance Cover SumExpr i where
    BoolCover :: Cover SumExpr TBool
    SumCover :: forall a b -> Cover SumExpr (a `TSum` b)

  data instance Gen SumExpr c k where
    TrueCovers :: Gen SumExpr BoolCover TUnit
    FalseCovers :: Gen SumExpr BoolCover TUnit

    LeftCovers :: Gen SumExpr (SumCover a b) a
    RightCovers :: Gen SumExpr (SumCover a b) b

This is equivalent to saying that sheaves for SumExpr have two gluing functions, glueIfThenElse and glueCase, such that in glueCase the Left alternative is passed an a and the Right alternative is passed a b, like we expect of a case expression.

Now, all instances from the previous section can be written in this abstract style. Except the instance for the Yoneda embedding. In particular, if you add a covering family for an object which isn’t a colimit in the base category, then the Yoneda embedding won’t yield sheaves. If you want to look this up, topologies where the Yoneda embedding only yields sheaves are called subcanonical.

Abhinav Sarkar: Nix for Haskell: Static Builds

abhinav@abhinavsarkar.net (Abhinav Sarkar) — Thu, 18 Jun 2026 00:00:00 +0000

In the previous post, we learned how to get started with managing and building a Haskell project with Nix. In this post, we learn how to easily create statically-linked executables for Haskell projects with Nix.

This post was originally published on abhinavsarkar.net.

This post is a part of the series: Nix for Haskell.

Getting Started
Static Builds ğŸ‘ˆ

I recommend going through the previous post, because we are going to start off from where we left last time (ignoring the bonus sections). This is how our projectâ€™s directory tree looks at this point:

.
|â€” app
|Â  |â€” Main.hs
|â€” ftr.cabal
|â€” nix
|Â  |â€” nixpkgs.nix
|Â  |â€” sources.json
|Â  |â€” sources.nix
|â€” package.nix
|â€” shell.nix

Main.hs is the default generated main file that prints â€œHello, Haskell!â€�. ftr.cabal is the default generated Cabal file. sources.(json|nix) are generated by Niv to pin Nixpkgs to a particular revision. nixpkgs.nix provides the nixpkgs that we use for building tools and dependencies. package.nix and shell.nix build the package and manage the Nix shell respectively. We are not going to touch any of these files in this post. Letâ€™s get started.

Static Builds#

A static build is an executable that is statically-linked against all the libraries it depends on. This is in contrast to a dynamically-linked executable, which contains references to the libraries it depends on, and those libraries are loaded and linked when the executable runs. While dynamic linking has its benefits, the main advantage of static linking is that the executable can be shipped by itself, without needing to ship or install dependency libraries. This makes it quite attractive for deploying backend services. You download and deploy that one binary executable file and you are done! No need to care about installing and maintaining its dependencies.

Many compilers support static buildsâ€”Go and Rust being two. Haskell compiler GHC also supports it, but not out-of-the-box. To statically link a Haskell executable, we need to configure GHC itself, and then configure the executable build as well. We also need to configure GHC to link with musl libc. Thatâ€™s where Nix helps us by smoothing out the process¹.

Enabling Static Builds in GHC#

As mentioned, first we need a GHC configured to do static builds. We create a nixpkgs derivation, separate from nixpkgs.nix, that contains the custom configured GHC.

{
  arch,
  ghcVersion ? (import ./nixpkgs.nix { }).haskellPackages.ghc.version,
}:
let
  getGHCWithVersion = lib: "ghc" + lib.replaceStrings [ "." ] [ "" ] ghcVersion;
  sources = import ./sources.nix;
in
import sources.nixpkgs {
  system = arch + "-linux";
  overlays = [
    ( final: prev:
      let
        compiler = getGHCWithVersion prev.lib;
        prevHPackages = prev.haskell.packages.${compiler};
      in prev.lib.attrsets.recursiveUpdate prev {
        haskell.packages.${compiler} = prevHPackages.override {
          ghc = prevHPackages.ghc.override {
            enableRelocatedStaticLibs = true;
            enableShared = false;
            enableDwarf = false;
            enableProfiledLibs = false;
            enableDocs = false;
            enableNativeBignum = true;
          };
          buildHaskellPackages = prevHPackages.buildHaskellPackages.override (old: {
            ghc = final.haskell.packages.${compiler}.ghc;
            buildHaskellPackages = final.haskell.packages.${compiler};
          });
        };
      })

    ( final: prev:
      let compiler = getGHCWithVersion prev.lib;
      in {
        haskellPackages = prev.haskell.packages.${compiler};
        ghc = prev.haskell.packages.${compiler}.ghc;
      })

    ( final: prev: {
      haskell = prev.haskell // {
        packageOverrides = prev.lib.composeExtensions prev.haskell.packageOverrides (
          hfinal: hprev: {
            mkDerivation = args:
              hprev.mkDerivation (
                args // {
                  doCheck = false;
                  doHaddock = false;
                  enableLibraryProfiling = false;
                  enableExecutableProfiling = false;
                });
          });
      };
    })
  ];
  config = { };
}

nix/nixpkgs-static-ghc.nix

Letâ€™s go over it piece-by-piece. First, we take the arch and ghcVersion parameters, letting us build the package for different architectures (X86-64 and AArch64), and for different GHC versions. We default the ghcVersion to the default GHC in nixpkgs.

The derivation is same as nixpkgs.nix, except we add some overlays. The first overlay adds the custom configured GHC for static builds. We enable certain configurations for that purpose:

enableRelocatedStaticLibs = true: Configures GHC runtime system and core packages to be built with position independent code so that they can be loaded for template Haskell.
enableShared = false: Disables building dynamically-linkable libraries, so they are built only as static archives.
enableDwarf = false: Disables DWARF-based stack traces, because it is unavailable on musl targets.
enableProfiledLibs = false: Disables building profiling enabled libraries.
enableDocs = false: Disables generation of documentation.
enableNativeBignum = true: Makes GHC use pure-Haskell based native bignum backend ghc-bignum instead of GMP, so that the package executables it creates are GPL-free. You may remove this setting if you are okay with GPL executables.

The buildHaskellPackages related lines set the custom GHC as the compiler for Haskell-based tools used in Nix².

The second overlay makes cabal2nixâ€”the tool used to convert .cabal files into Nix derivationsâ€”use the custom GHC. The third overlay disables documentation generation, testing, and profiling of all Haskell libraries built with the custom GHC. We do this to save the build time, assuming that static builds are for release only, and the docs, tests, and profiling are done using a normal GHC.

Building this custom GHC may take anywhere from several minutes to several hours depending on the build machine configuration³ ⁴. But this is a one-time price to pay, as long as we keep the GHC build around. Next, we configure our package to be built as a statically-linked executable.

Configuring the Application#

The package-static.nix file is equivalent of the package.nix file from the previous post, but builds statically-linked exes.

{
  arch,
  ghcVersion ? (import ./nix/nixpkgs.nix { }).haskellPackages.ghc.version,
}:
let
  pkgsOrig = import ./nix/nixpkgs-static-ghc.nix { inherit arch ghcVersion; };
  pkgs = pkgsOrig.pkgsMusl;
  hlib = pkgs.haskell.lib.compose;

  staticDeps = import ./nix/static-deps.nix { inherit pkgs; };
  inherit (staticDeps) libffi zlib numactl;
in
pkgs.lib.pipe
  (pkgs.haskellPackages.callCabal2nix "ftr" (pkgs.lib.cleanSource ./.) { })
  [ hlib.dontHaddock
    hlib.dontHyperlinkSource
    hlib.dontCoverage
    hlib.disableExecutableProfiling
    hlib.disableLibraryProfiling
    hlib.disableSharedLibraries
    hlib.justStaticExecutables
    hlib.enableDeadCodeElimination
    ( hlib.overrideCabal (old: {
      enableParallelBuilding = true;
      buildTools = (old.buildTools or [ ]) ++ [ pkgsOrig.buildPackages.lld ];
    }))
    ( hlib.appendConfigureFlags [
      "-O2"
      "--ghc-option=-fPIC"
      "--ghc-option=-optl=-static"
      "--ghc-option=-split-sections"
      "--ghc-option=-optl-fuse-ld=lld"
      "--ld-option=-fuse-ld=lld"
      "--with-ld=ld.lld"
      "--ld-option=-Wl,--gc-sections,--build-id,--icf=all"
      "--extra-lib-dirs=${libffi}/lib"
      "--extra-lib-dirs=${zlib}/lib"
      "--extra-lib-dirs=${numactl}/lib"
    ])
    ( src: pkgs.stdenv.mkDerivation {
      name = "${src.name}-compressed";
      inherit src;
      nativeBuildInputs = [ pkgsOrig.upx ];
      installPhase = ''
        mkdir -p $out
        cp -R $src/. $out
        chmod -R +w $out/bin
        upx -q --lzma -1 $out/bin/*
        chmod -R -w $out/bin
      '';
    })
  ]

package-static.nix

Letâ€™s go over the file in parts.

package-static.nix also takes arch and ghcVersion as parameters, and passes them to nix/nixpkgs-static-ghc.nix to create the nixpkgs with the custom GHC as described above. This give us pkgsOrig, from which we get the pkgsMusl version. pkgsMusl is same nixpkgs, except every executable in it links to musl libc. We capture this as pkgs, and use it to build our Haskell package.

When linking the executable, we need to link it against static version of all the dependency libraries it depends on. Thatâ€™s what nix/static-deps.nix file provides us. Weâ€™ll look at it in the next section, but for now, we see that it gives us the libffi, zlib, and numactl libraries⁵.

Finally, we get to the package configuration. It starts the same as package.nix, using cabal2nix to connect the Haskell project to Nix, but then, we provide a list of custom configurations. We disable Haddock docs, hyperlinked source docs, coverage tests, profiling, and shared library build. We enable static executable build and dead code elimination. Then we configure cabal to run builds with multithreading, and add lld to its list of build tools.

Then, we add many configuration flags:

-O2: Enables optimization.
--ghc-option=-fPIC: Enables emission of position independent code.
--ghc-option=-optl=-static: Enables static linking.
--ghc-option=-split-sections: Enables split sections to produce smaller binaries.
--ghc-option=-optl-fuse-ld=lld, --ld-option=-fuse-ld=lld, --with-ld=ld.lld: Configures GHC to use lld as the linker, which is much faster than the default linker. You can omit these lines to use the default linker. Or you can replace all metions of lld with mold to use the Mold linker, which may be even faster depending on your project.
--ld-option=-Wl,--gc-sections,--build-id,--icf=all: Enables reductions in binary size by removing dead code⁶.

--extra-lib-dirs=...: These lines allow GHC to link the output executable against the static version of the mentioned dependency libraries.

Finally, the last function in the pipeline uses UPX to compress the output executable. This generally results in a large reduction in the binary size⁷.

Now we can actually build the statically-linked exe:

$ nix-build --argstr arch x86_64 package-static.nix
$ nix-build --argstr arch aarch64 package-static.nix
$ nix-build --argstr arch x86_64 --argstr ghcVersion "9.12" package-static.nix

The first and second line above build the exe for the X86-64 and AArch64 architectures with the default GHC version. The third line specifies a different GHC version to build with. Here is the cleaned-up output log for the first command:

Output log

$ nix-build --argstr arch x86_64 package-static.nix
these 2 derivations will be built:
  /nix/store/42a291bq7ydvkdy3fdsyj82axrfsi6sy-ftr-0.1.0.0.drv
  /nix/store/2c2l50la8291q0jrqlc23bybaxwip8y2-ftr-0.1.0.0-compressed.drv
building '/nix/store/42a291bq7ydvkdy3fdsyj82axrfsi6sy-ftr-0.1.0.0.drv' on 'ssh-ng://builder@linux-builder'...
copying 1 paths...
copying path '/nix/store/l9ls307kzxby72hqj4yl7ri7m8s3b3fk-source' to 'ssh-ng://builder@linux-builder'...
building '/nix/store/42a291bq7ydvkdy3fdsyj82axrfsi6sy-ftr-0.1.0.0.drv'...
Running phase: setupCompilerEnvironmentPhase
Build with /nix/store/717lxds14ra0ndbnin2qhdhh91d3b69g-ghc-musl-native-bignum-9.10.3.
Running phase: unpackPhase
unpacking source archive /nix/store/l9ls307kzxby72hqj4yl7ri7m8s3b3fk-source
source root is source
Running phase: patchPhase
Running phase: compileBuildDriverPhase
setupCompileFlags: -package-db=/nix/var/nix/b/10kwxdphxvyy519y831ryji7fn/b/tmp.EPOEKNjT6Z/setup-package.conf.d -threaded
[1 of 2] Compiling Main             ( /nix/store/4mdp8nhyfddh7bllbi7xszz7k9955n79-Setup.hs, /nix/var/nix/b/10kwxdphxvyy519y831ryji7fn/b/tmp.EPOEKNjT6Z/Main.o )
[2 of 2] Linking Setup
Running phase: updateAutotoolsGnuConfigScriptsPhase
Running phase: configurePhase
configureFlags: --verbose --prefix=/nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0 --libdir=$prefix/lib/$compiler/lib --libsubdir=$abi/$libname --with-gcc=gcc --package-db=/nix/var/nix/b/10kwxdphxvyy519y831ryji7fn/b/tmp.EPOEKNjT6Z/package.conf.d --ghc-option=-j4 --ghc-option=+RTS --ghc-option=-A64M --ghc-option=-RTS --disable-library-profiling --disable-profiling --disable-shared --disable-coverage --enable-static --disable-executable-dynamic --disable-tests --disable-benchmarks --enable-library-vanilla --disable-library-for-ghci --enable-split-sections --enable-library-stripping --enable-executable-stripping -O2 --ghc-option=-fPIC --ghc-option=-split-sections --ghc-option=-optl-fuse-ld=lld --ld-option=-fuse-ld=lld --ld-option=-Wl,--gc-sections,--build-id,--icf=all --with-ld=ld.lld --ghc-option=-optl=-static --extra-lib-dirs=/nix/store/yi771fg1dfj1bg618vv5flmisy8zw3hm-libffi-3.5.2/lib --extra-lib-dirs=/nix/store/jk77s356gjn68dcrzpz1m7m5amzxmkw8-zlib-1.3.2-static/lib --extra-lib-dirs=/nix/store/044b10glmg0f3yyijmrwrgv5lsys6x6n-numactl-2.0.18/lib --extra-lib-dirs=/nix/store/m1j2f9b1h6pbq1mq5ibnw4cpp60w5dfi-libffi-3.5.2/lib --extra-include-dirs=/nix/store/j9c1ifaa7vph3zxfbzb55y1frm0vp4xm-musl-iconv-1.2.5/include --extra-lib-dirs=/nix/store/lrrmafbkrpa4f3wxfz6a3sd3dv6xgp7n-numactl-2.0.18/lib

[snip]

Running phase: buildPhase
Preprocessing executable 'ftr' for ftr-0.1.0.0...
Building executable 'ftr' for ftr-0.1.0.0...
[1 of 1] Compiling Main             ( app/Main.hs, dist/build/ftr/ftr-tmp/Main.o )
[2 of 2] Linking dist/build/ftr/ftr
Running phase: haddockPhase
Running phase: installPhase
Installing executable ftr in /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0/bin
Warning: The directory
/nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0/bin is not in the
system search path.
Running phase: fixupPhase
shrinking RPATHs of ELF executables and libraries in /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0
shrinking /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0/bin/ftr
patchelf: cannot find section '.dynamic'. The input file is most likely statically linked
checking for references to /nix/var/nix/b/10kwxdphxvyy519y831ryji7fn/b/ in /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0...
patchelf: cannot find section '.dynamic'. The input file is most likely statically linked
patching script interpreter paths in /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0
stripping (with command strip and flags -S -p) in  /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0/bin
copying 1 paths...
copying path '/nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0' from 'ssh-ng://builder@linux-builder'...
building '/nix/store/2c2l50la8291q0jrqlc23bybaxwip8y2-ftr-0.1.0.0-compressed.drv' on 'ssh-ng://builder@linux-builder'...
copying 0 paths...
building '/nix/store/2c2l50la8291q0jrqlc23bybaxwip8y2-ftr-0.1.0.0-compressed.drv'...
Running phase: unpackPhase
unpacking source archive /nix/store/pb2zay1k8b0vifhx7ghd5j6lbncq4b66-ftr-0.1.0.0
source root is ftr-0.1.0.0
Running phase: patchPhase
Running phase: updateAutotoolsGnuConfigScriptsPhase
Running phase: configurePhase
no configure script, doing nothing
Running phase: buildPhase
no Makefile or custom buildPhase, doing nothing
Running phase: installPhase
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2026
UPX 5.1.1       Markus Oberhumer, Laszlo Molnar & John Reiser    Mar 5th 2026

        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
   1356096 ->    525804   38.77%   linux/amd64   ftr                           bin/ftr [linux/amd64, LZMA/1]

Packed 1 file.
Running phase: fixupPhase
shrinking RPATHs of ELF executables and libraries in /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed
shrinking /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed/bin/ftr
patchelf: no section headers. The input file is probably a statically linked, self-decompressing binary
checking for references to /nix/var/nix/b/19b7g2frvcvani3cnj61lsb4fq/b/ in /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed...
patchelf: no section headers. The input file is probably a statically linked, self-decompressing binary
patching script interpreter paths in /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed
stripping (with command strip and flags -S -p) in  /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed/bin
copying 1 paths...
copying path '/nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed' from 'ssh-ng://builder@linux-builder'...
/nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed

The output log mentions:

patchelf: cannot find section â€˜.dynamicâ€™. The input file is most likely statically linked

We can also verify for ourselves:

$ file /nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed/bin/ftr
/nix/store/j8gg1x3vrlb5dc1mh149ys0nih9fvmwk-ftr-0.1.0.0-compressed/bin/ftr: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), BuildID[sha1]=df53df80d301b4bba2a7634a4169c6291d64ea72, statically linked, no section header

There is one last thing to take care of.

Rooting Static Build Dependencies#

Dynamically-linked Haskell builds contain references to their dependency libraries and GHC that was used to build it. If you use direnv or install a dynamically-linked executable, it creates Nix GC roots for the libraries and GHC, preventing them from being garbage-collected by Nix. But statically-linked builds have no references to anything, as intended. So we need to create GC roots by ourselves to the libraries and the GHC toolchain. This is even more important because building the custom GHC may be an extremely time-consuming affair.

First, we list all dependencies in a separate file:

{ pkgs }:
{
  ghc = pkgs.haskellPackages.ghc;
  jailbreak-cabal = pkgs.haskellPackages.buildHaskellPackages.jailbreak-cabal;
  cabal2nix-unwrapped = pkgs.cabal2nix-unwrapped;
  gmp6 = pkgs.gmp6.override { withStatic = true; };
  libffi = pkgs.libffi.overrideAttrs (old: { dontDisableStatic = true; });
  ncurses = pkgs.ncurses.override { enableStatic = true; };
  zlib = pkgs.zlib.static;
  numactl = pkgs.numactl.overrideAttrs (oldAttrs: {
    configureFlags = (oldAttrs.configureFlags or [ ]) ++ [
      "--enable-static"
      "--disable-shared"
    ];
  });
}

nix/static-deps.nix

This file lists the dependency libraries and the GHC toolchain. Notice how we override each libraryâ€™s config to make it statically-linkable. Iâ€™ve included some additional libraries here (gmp6 and ncurses) that are generally used by Haskell projects, but we donâ€™t use them in this project. You may have to add more of such libraries depending on your projectâ€™s dependencies.

We already saw how we use this file in package-static.nix. Now, we use it to create Nix GC roots:

{
  arch,
  ghcVersion ? (import ./nix/nixpkgs.nix { }).haskellPackages.ghc.version,
}:
let
  pkgsOrig = import ./nix/nixpkgs-static-ghc.nix { inherit arch ghcVersion; };
  pkgs = pkgsOrig.pkgsMusl;
in pkgs.symlinkJoin {
  name = "static-deps";
  paths = builtins.attrValues (import ./nix/static-deps.nix { inherit pkgs; });
}

package-static-deps.nix

package-static-deps.nix simply gathers all dependencies from nix/static-deps.nix and creates a directory with symlinks to them. This brings us to the finale.

Finale#

We create a bash script build-static.sh that builds the statically-linked executable, and creates Nix GC roots for all dependencies and the toolchain:

#!/usr/bin/env bash
set -euo pipefail

nix-build --argstr arch "$1" package-static.nix
nix-store --add-root ".gcroots/static-deps-$1" \
  --realise $(nix-instantiate --argstr arch "$1" --quiet package-static-deps.nix) \
  > /dev/null

build-static.sh

The root is created at .gcroots/static-deps-x86_64 for X86-64 architecture, for example. You can use nix-tree to explore it.

This concludes our short tutorial on how to build statically-linked executables for Haskell projects with Nix.

Bonus: Building a Docker Image#

One more thing static builds are great for: wrapping them into Docker images. Since they are much smaller than dynamically-linked executables and their dependencies combined, they are better to package as Docker images. Hereâ€™s how we do it:

{ arch }:
let
  pkgs = import ./nix/nixpkgs.nix { system = arch + "-linux"; };
  ftr = import ./package-static.nix { inherit arch; };
in
pkgs.dockerTools.buildLayeredImage {
  name = "ftr";
  tag = "latest";
  contents = [ pkgs.dockerTools.caCertificates ftr ];

  extraCommands = ''
    mkdir -p var/lib/ftr var/cache/ftr etc/ftr
    echo 'ftr:x:1000:1000::/var/lib/ftr:/sbin/nologin' > etc/passwd
    echo 'ftr:x:1000:' > etc/group
  '';
  fakeRootCommands = ''
    chown -R 1000:1000 var/lib/ftr var/cache/ftr
  '';
  enableFakechroot = true;

  config = {
    User = "1000:1000";
    Cmd = [ "/bin/ftr" ];
    Volumes = {
      "/var/lib/ftr" = { };
      "/var/cache/ftr" = { };
      "/etc/ftr" = { };
    };
  };
}

docker.nix

This image also shows how to package extra Nix packages in images, setting up a non-root user to run the executable, and setting up user-owned directories to expose as volumes. We can build the image by running:

$ nix-build --argstr arch x86_64 docker.nix
[snip]
/nix/store/cdghjrgdcf7vm0jbgjl5556zx3j4zjj1-ftr.tar.gz

Then we can load and run the image on Docker like so:

$ docker load -i /nix/store/cdghjrgdcf7vm0jbgjl5556zx3j4zjj1-ftr.tar.gz

Conclusion#

This post shows how to configure GHC and Haskell projects to build statically-linked executables that are fully portable and independent. If your Haskell project has any complex requirements, such as custom dependency versions, patched dependencies, custom non-Haskell dependencies etc., this setup may not scale. In such case you can either grow this setup by learning Nix in more depth with the help of the official Haskell with Nix docs and this great tutorial, or switch to using a framework like haskell.nix or haskell-flake. For dealing with complex static builds, static-haskell-nix project may be of help.

If you have any questions or comments, please leave a comment below. If you liked this post, please share it. Thanks for reading!

You may need a remote Nix Linux builder to build GHC and your package if you are not on Linux or not on the right architecture. You may set up a remote builder or Linux builder on macOS.â†©ï¸�
Some of your projectâ€™s dependency libraries may link to GMP directly. In such cases, the libraries provide Cabal flags to remove GMP dependency. If you donâ€™t want GMP linked to your executable, youâ€™ll need to override the Nix derivation for such libraries to pass those Cabal flags.â†©ï¸�
I learned about using these flags from the post â€œLinking Smaller Haskell Binariesâ€�. It mentions few mores tricks that may be useful to you.â†©ï¸�
Note that we get the tools lld and upx from pkgsOrig, the original nixpkgs, not the musl one. We donâ€™t need musl version of these tools for them to work, and doing that would simply cause our builds to take longer.â†©ï¸�

This post is a part of the series: Nix for Haskell.

Getting Started
Static Builds ğŸ‘ˆ

Thanks for reading this post via feed. Feeds are great, and you're great for using them. â™¥

This post was originally published on abhinavsarkar.net.

Like, repost, or comment on:

Haskell Interlude: 83: POPL 2026 - Part 2

Sun, 14 Jun 2026 18:00:00 +0000

This is the first part of a miniseries on this yearâ€™s Symposium on Principles of Programming Languages, a.k.a. POPL 2026, hosted by Jessica Foster.

In this episode we talk about: symbolic execution monads, what a lazy linear core in Haskell might have in common with Rust, hyperfunctions, the hallway track, and how to deal with rejection.

Tweag I/O: Writing static checks to an unsuspecting library with Liquid Haskell

Thu, 11 Jun 2026 00:00:00 +0000

This post presents a little epic to insert static checks in Haskell’s Diff package using Liquid Haskell (LH).¹ Static or compile-time checks are helpful to confirm formerly implicit assumptions in the implementation, providing an additional layer of assurance.

Making illegal states unrepresentable at an affordable cognitive cost is a staple of statically typed functional programming. Endeavors like Dependent Haskell and Liquid Haskell delve into this aspect. A distinctive feature of LH is that it works on top of regular Haskell code, meaning that the program can still be compiled after disabling it, thus making it possible to enforce properties without changing the source code. In what follows I’ll give you a glimpse of how the Liquid Haskell approach feels in practice and how far it can go.

Liquid Haskell was created by the UCSD Programming Systems group and these days is mainly maintained and further improved by my colleague Facundo Domínguez. Applying Liquid Haskell to strengthen libraries has precedent in the Haskell ecosystem, and it was in this spirit that Facundo suggested this project as we were pondering an attempt to statically check our in-house Ormolu, of which Diff is a transitive dependency and a more suitable commitment given the engineering time I could bestow upon it.²

`Diff` will never be the same

The Diff package is a small and (relatively) self-contained library implementing the Myers diff algorithm. As a provider of basic functionality in the Haskell ecosystem, adding formal guarantees to it is of intrinsic value to the community.

From the get-go, my objective was adding static checks to strengthen this library in a contribution guided by two opposing desiderata:

Minimize source changes
Maximize checked invariants

While the first is about testing how (non-)intrusive Liquid Haskell can be, the second is about its expressiveness. To put it bluntly, the ideal LH would be able to statically check all the existing invariants of an unsuspecting library using nothing more than specification annotations. Reality is not that kind, forcing me to compromise on both objectives, but I kept this mindset to help me see how close LH is to this ideal.

My first milestone was filling the mind gap between the Diff implementation and the referenced paper’s algorithm, through an in-depth study of the library, resulting in documentation contributions highlighting the most salient invariants (pre- and post-conditions) and assumptions.³

In general, it is by a careful threading of logic that a program is built into existence; the problem (and the source of well engineered solutions) is that the critical aspects of it lie within a theory in its writer’s mind, which tends to be lost across iterations, updates, refactors and people moving on. Both documentation and specification cannot completely solve this problem, but they can help.

For example, I added a post-condition to this function haddock

data PolyDiff a b = First a | Second b | Both a b

-- | Like 'getGroupedDiff' but accepts a custom equality predicate.
--
-- Postcondition: the output list is guaranteed to be /chunked/. i.e. no two adjacent
-- elements share the same constructor.
getGroupedDiffBy :: (a -> b -> Bool) -> [a] -> [b] -> [PolyDiff [a] [b]]

making the expected form of its output explicit. This allows a reader to get an immediate notion of what the implementation is supposed to accomplish in order to satisfy the caller’s expectations.

Similarly, data types often carry more meaning than what they actually encode, in which case documenting the implicit assumptions can help understand their intended use.

-- | Line Range: start, end and contents.
--
-- The following invariants hold:
--
-- > snd lrNumbers >= fst lrNumbers
-- > snd lrNumbers - fst lrNumbers + 1 == length lrContents
--
-- which imply @lrContents@ cannot be empty.
data LineRange = LineRange { lrNumbers :: (LineNo, LineNo)
                           , lrContents :: [String]
                           }

These haddocks are inspired by the kind of properties that LH can express. Nevertheless, their value doesn’t depend on providing static checks as they already save us from some arduous code path diving. Wouldn’t it be wonderful if the compiler could take those haddocks to heart? In a sense that’s what LH is about!

Engineering the static checks took me into a tight feedback loop between the documentation process, coming up with refactorings⁴ to make the code easier to check (which always implied easier to explain!) and the writing of LH specifications matching the documented invariants. This approach is in close sympathy with the doc it like it’s hot philosophy.

From dry code to liquid types

After installing LH, compilation failed due to new shiny errors, even though I hadn’t written a single LH specification yet. This is because LH inspects the bodies of all function definitions out of the box to prove that

Existing specifications are fulfilled
Recursive functions terminate

The first condition is not limited to local specifications; LH comes bundled with specifications for many boot package functions. For instance, many of Prelude’s partial functions are refined this way to be total, so LH tries to prove that all their uses are safe.

One prominent example is head, which was the only failure of the first condition in Diff: it was not certain that the list passed to head in its ses function is always non-empty, which can be found to be true from the algorithm specification and by following the composition of the involved processes. LH tries to build this knowledge from specifications, in the form of refinement types, found along the call stack. Such specifications are introduced using a special comment syntax {-@ ... @-} whose contents are processed to generate a set of constraints for an external SMT solver to verify. This allows us to mechanically check function specifications, formed out of pre- and post-conditions, and data invariants expressed as simple logical predicates at compile time. In what follows I’ll show some examples of LH specification annotations, but in most cases I won’t be explaining their syntax or fundamentals, trusting that their meaning within the general argument can be gathered from context. For further details please look at the spec reference documentation.

The same comment syntax is also used to set LH directives, like the ignore annotation I used to skip checks in the body of the offending ses function.

{-@ ignore ses @-}
ses :: (a -> b -> Bool) -> [a] -> [b] -> [DI]
ses eq as bs = path . head . dropWhile (\dl -> poi dl /= lena || poj dl /= lenb) .
            concat . iterate (dstep cd) . (:[]) . addsnake cd $
            DL {poi=0,poj=0,path=[]}
            where cd = canDiag eq as bs lena lenb
                  lena = length as; lenb = length bs

Turning now to the second condition: To prove termination of a recursive function, LH needs to be told of a size reduced towards a lower bound at each recursive call. This is called a termination metric.

Some recursive functions might be proved terminating without intervention, because when no explicit metric is given LH follows a simple heuristic: it checks for the first (non-function) argument with an associated size metric to be strictly decreasing and non-negative at each recursive call. LH has definitions of associated size metric for lists (their length) and integer values, which are considered metrics themselves when non-negative. Metrics get interesting when we have mutually recursive functions, as is the case for doPrefix and doSuffix, a pair of local functions whose job is to chop common lines of input to create the context windows that make a diff’s hunks. I introduced a lexicographic metric, annotated with the syntax / [metric1, metric2, ...] at the end of a function refinement, to prove their termination:

type Diff c = PolyDiff c c

{-@ doPrefix :: hunk : [Diff [c]] -> [Diff [c]] / [len hunk, 0] @-}
doPrefix :: [Diff [c]] -> [Diff [c]]
doPrefix [] = []
doPrefix [Both _ _] = []
doPrefix (Both xs ys : more) =
  Both (drop (length xs - contextSize) xs)
       (drop (length ys - contextSize) ys)
    : doSuffix more
doPrefix (d : ds) = d : doSuffix ds

{-@ doSuffix :: hunk : [Diff [c]] -> [Diff [c]] / [len hunk, 1]@-}
doSuffix :: [Diff [c]] -> [Diff [c]]
doSuffix [] = []
doSuffix [Both xs ys] = [Both (take contextSize xs) (take contextSize ys)]
doSuffix (Both xs ys : more)
  | length xs <= contextSize * 2 = Both xs ys : doPrefix more
  | otherwise =
      Both (take contextSize xs) (take contextSize ys) :
        doPrefix (Both (drop contextSize xs) (drop contextSize ys) : more)
doSuffix (d : ds) = d : doSuffix ds

Using this metric LH checks that either the input hunk (a list of diff elements) length is reduced after each recursive call, as it would do by its default heuristic, or considers a call to doPrefix (0) from doSuffix (1) to be a strict reduction. This second fallback metric is needed because of the third equation of doSuffix (second guard), where doPrefix is called with a list of equal length. Apart from this case, each (mutually) recursive call is done on the tail of the input and thus strictly decreasing.

Here I’ve presented instances of two general strategies to handle LH errors:

Fight: Fix the failing termination checks by introducing metrics and offending functions calls by adding specifications.
Flight: Disable checks by using an escape hatch, e.g. the {-@ lazy myRecursiveFunction @-} annotation to circumvent termination checking, the {-@ ignore myOffendingFunction @-} to disable all checks within a function’s body or the {-@ assume myFunction :: ... spec ... @-} to set a function specification as true without verification.

A priori it’s desirable to minimize the use of escape hatches, but they’re also tools to prioritize static checking efforts.

Invariant static checking

One thing that made Diff particularly suitable for this effort is that a detailed specification of it existed in the form of a research paper. Indeed, my first documentation contribution was making their connection explicit throughout. The Myers diff algorithm can be summarized as a breadth-first search for the shortest path across a bidimensional edit grid to an endpoint,⁵ the latter representing the complete transformation of one input to the other. The algorithm is in fact tersely expressed in the ses definition presented before; its name stands for “smallest edit script”, which is one of the output characterizations of the diff algorithm. What I found is that the idea of a wave front is the link between this implementation and the original algorithm. This statement is now supported by a static check showing that a wave front is transformed as the algorithm prescribes for its inner loop.

A wave front is defined as a list of nodes at the same depth, i.e. the edit trace length, which is iterated upon by the dstep function to return nodes one step deeper. This function is a direct implementation of the extension procedure used by the algorithm at each search step. Furthermore, the paper proves a pair of lemmas that result in a specific configuration of the node list after each iteration, which is related to the diagonals on the edit grid and checked by a wfDiags predicate that I wrote to specify it. The details of this condition aren’t essential here: while the paper leverages it to introduce a space optimization, the Haskell implementation doesn’t depend on it, but the configuration is preserved nonetheless.

I encoded the fixed depth of nodes and their diagonal configuration using refinement type aliases to obtain a wave front specification.

-- | A node representing the tip of a path in the edit grid.
data DL = DL
    { ...
    , path :: [DI]   -- ^ The edit trace accumulated so far
    } deriving (Show, Eq)

-- A node at a fixed edit trace length (depth).
{-@ type DLN D = { x : DL | len (path x) = D } @-}

-- | This function is used only in LH specs to check if
-- diagonal configuration holds for a node list.
wfDiags :: [DL] -> Bool
wfDiags = ...

-- All nodes in a wave front are at the same depth,
-- and satisfy the diagonal configuration.
{-@ type WaveFront D = {xs : [DLN D] | wfDiags xs} @-}

With this encoding, and a phantom parameter carrying the current depth, I specified dstep (called from ses) to match the algorithm behavior (which also includes the node list growing by one).

{-@
dstep
  :: (Nat -> Nat -> Bool)
  -> d : Nat
  -> {nodes : WaveFront d | len nodes > 0}
  -> {v : WaveFront (d + 1) | len v = len nodes + 1}
@-}
dstep
  :: (Int -> Int -> Bool) -- ^ Check for node coordinates producing a free edge
  -> Int                  -- ^ The current depth; used for the static check of the wave front invariant
  -> [DL]                 -- ^ A non-empty wave front of nodes at edit distance D
  -> [DL]                 -- ^ A non-empty wave front of nodes at edit distance D+1

Refinement type aliases become statically checked invariants when used in a function specification, and are verified to hold at each call site.

As a second example, let’s see the invariants of a Hunk, expressed again using refinement type aliases.

-- A valid list diff is such that any `Both` value has arguments of equal length.
{-@ type ValidListDiff a b = { d : PolyDiff [a] [b] | validListDiff d }@-}

-- | True when, for a 'Both' value, both sides have the same length.
-- 'First' and 'Second' trivially satisfy this.
-- Introduced for LH specifications.
validListDiff :: PolyDiff [a] [b] -> Bool
validListDiff (Both xs ys) = length xs == length ys
validListDiff _ = True

-- | True if the list does not contain adjacent 'PolyDiff's with the same constructor.
noStuttering :: [PolyDiff a b] -> Bool
noStuttering = ...

-- | A 'Hunk' is a list of adjacent 'Diff's.
--
-- No two consecutive elements in a 'Hunk' are both applications
-- of 'First', 'Second', or 'Both', i.e. the list does not stutter
-- on 'Diff' constructors.
type Hunk c = [Diff [c]]

{-@ type Hunk c = { h : [ValidListDiff c c] | noStuttering h} @-}

The interesting part here is the check for the noStuttering invariant in the specification of the main Hunk producing function. For brevity’s sake I won’t show this function, but let’s see what came to be of the specification of the previously presented doPrefix, that is part of it, for the check to pass.

{-@ doPrefix ::  h : Hunk c
             -> {v : [ValidListDiff c c] | noFFSS v
                 && ... other auxiliary post-conditions ... } / [len h, 0] @-}

Essentially, this function traverses a given Hunk and chops and splits Both elements to a context size argument. After doing so the Hunk “stutters” on such elements, so it stops being a Hunk in the refined sense, even though the Haskell types match. Note the regular type synonym and the refinement type synonym don’t coalesce: At the Haskell level the synonym is just a renaming, but in the specification it is shadowed by the refinement synonym (thus enforcing its invariants). The noFFSS helper characterizes the resulting list; it is like noStuttering, but just for the other PolyDiff constructors: First and Second. Other auxiliary post-conditions (not shown) stating that input and output lists shared head constructors were also necessary for this check.

The verification of these and other invariants followed a similar outline:

Identify and document the invariant
Encode it in refinements
Write the specifications
Please the compiler

Pleasing the compiler after adding a new specification was trickier for me than the usual Haskell type error propagation and fix workflow. Figuring out exactly what LH is aware of when checking a specification requires an intuition of how it builds a context; then it’s a matter of making the missing information available.

For instance, the last step to get back a Hunk after the doPrefix-doSuffix operation required passing a lemma within a local dead binding for the specification to be verified.

{-@ assume lemmaReverseNoStuttering
      :: xs:_ -> { noStuttering (reverse xs) = noStuttering xs } @-}
lemmaReverseNoStuttering :: Hunk c -> ()
lemmaReverseNoStuttering _ = ()

-- | Split a 'Diff' list at consecutive 'Both'-'Both' boundaries.
{-@ splitBothBoth :: {ds:[ValidListDiff c c] | noFFSS ds} -> [Hunk c] @-}
splitBothBoth :: [Diff [c]] -> [Hunk c]
splitBothBoth = go []
  where
    {-@ go
          :: g:Hunk c
          -> {xs : [ValidListDiff c c] | noFFSS xs && not (headAlike g xs) }
          -> [Hunk c] / [len xs]
      @-}
    go :: Hunk c -> [Diff [c]] -> [Hunk c]
    go g (x@Both{} : y@Both{} : xs) = reverse (x:g) : go [] (y:xs)
      where
        lemma = lemmaReverseNoStuttering (x:g)
    go g (x : xs) = go (x:g) xs
    go g [] = [reverse g]
      where
        lemma = lemmaReverseNoStuttering g

This binding ultimately gets optimized away by GHC, but LH requires it to satisfy the static checks. LH didn’t have a means to know that reverse preserves the noStuttering of a PolyDiff list, so I provided it.

I decided to assume the lemma above on the rationale that its validity is straight-forward, while its proof would probably not be, making the disease not worth the medicine.

Lifting a dam

After this work I’m flooded with many thoughts and feelings about LH from the user perspective, but also ideas for important future developments.

One particular source of difficulty I found is differentiating between the existing means of lifting a Haskell function into the logic: reflect, inline, measure and define. By default, Haskell functions like wfDiag cannot be used in the refinement type predicates. They have to be accompanied by an annotation that indicates how to make them available in the predicates, which I omitted in my examples for the sake of argument.

Existing documentation does a good job at explaining their requirements and purpose. Nevertheless, subtle differences in constraint generation and logical expression unfolding aren’t documented, and these details matter when choosing between them in certain cases. Addressing this could lead to unifying or deprecating some functionality, but at least specifying them at a finer grain and adding some use case examples could go a long way.

A more salient difficulty are the error messages. They can be baffling, featuring not very human friendly variable names spread across enormous lists of bindings forming their “context”. Skimming through this context is a skill that I would love to deprecate. Looking first at the “inferred type” and the “required type” part at the start of the message is a useful technique, which can provide a lead to the source of the problem.

I find refinement types appealing because they are powerful yet non-sophisticated enough to be intuitive. Nevertheless, getting a function specification checked can become intricate, requiring additional proving machinery like function definitions exclusively intended for refinement predicates, lemmas in dead bindings to pass additional constraints or even heavy refactoring. However, I think the upfront cost of entry can be easily balanced out by using the escape hatches to focus the effort investment. In the Diff package, for instance, some low hanging fruit could be picked right away after disabling the checks on error triggering functions, e.g. refining integer values to naturals or enforcing clear-cut relations between record fields, adding immediate value without additional machinery.

A drawback is that polymorphism seems at odds with the simplicity of refinements: the more we want to specify about a value or function, the more we narrow its type. That said, there seems to be a correlation between code complexity and LH verification complexity that is worth investigating further: changes that simplified the verification of an invariant tended to benefit the code quality independently of it.

Choosing between fight or flight for a given invariant is ultimately about balancing safety gains with added complexity, and in my experience the code structure is what tips the scale: it determined both the refactorings I needed and the checks I had to forgo. My guess is that the whole equation changes when refinement types are a first class consideration during design.

Clearing up the waters

Hopefully this little epic amounts to a useful case study that, by showing what using LH is like today, encourages you to add static checks to an existing codebase or experiment in your next project with LH in your toolbox, and the techniques I’ve shared help prioritize the approach.

I discussed some of LH pain points to offer a balanced view and propose further DX improvements. There’s much to be done, but it’s steadily getting there. My opinion is that Liquid Haskell is a viable option today to add formal guarantees to an unsuspecting codebase at a reasonable cost, as long as the palette of shapes and extent this can take is kept in mind during design. Know that you’re welcome to contribute to LH development and that we’re ready to help strengthen your codebase. Just reach out!

Finally, I would like to express my gratitude to Aleksandr Vershilov, Arnaud Spiwack and Christopher Harrison for reviewing this text, and notably to Facundo Domínguez whose close collaboration was instrumental to streamline this work.

At the time of writing, the static checks are about to be proposed for upstream integration. But they can be found in the Liquid Haskell test suite as well.↩
A nice perk of working at Tweag is being supported to do open source contributions during or in-between client projects.↩
Found in https://github.com/seereason/Diff/pull/21 and https://github.com/seereason/Diff/pull/23 ↩
Found in https://github.com/seereason/Diff/pull/24, https://github.com/seereason/Diff/pull/25, https://github.com/seereason/Diff/pull/26 and https://github.com/seereason/Diff/pull/27.↩
The coordinates of a node in the edit grid represent the size of the prefix consumed from the first input and the size of the produced prefix of the other input, respectively. Thus, the endpoint has coordinates matching both input lengths. The grid’s most relevant feature is that, in addition to vertical and horizontal edges (corresponding to deletions and additions, respectively), there are “free” diagonal edges wherever both inputs have matching elements.↩

Stackage Blog: Stackage talk at Haskell Ecosystem Workshop 2026

Mon, 08 Jun 2026 16:00:00 +0000

Stackage talk at Haskell Ecosystem Workshop 2026

Jens Petersen gave a talk about Stackage at the Haskell Ecosystem Workshop 2026 (4th June), organized by the Haskell Foundation before Zurihac.

Here are the html slides (single page html).

Gabriella Gonzalez: Ergonomic overrides for Nixpkgs

Sat, 06 Jun 2026 00:00:00 +0000

Announcement post for the override-utils Nix package

Well-Typed.Com: Faster Cabal Haskell builds by eliminating redundant work

Thu, 28 May 2026 00:00:00 +0000

TL;DR Build your Haskell projects 10-15% faster with this one simple trick! (Spoiler: the simple trick is to wait for the next major cabal-install release.)

In previous work (paid for by the Sovereign Tech Fund) we did a lot of heavy lifting to make a major architectural change to Cabal. That work is now paying off with practical benefits. This post covers follow-on architectural improvements to cabal-install which then enable us to eliminate redundant work in the configure phase, yielding significant reductions in build times.

The changes will be available to everyone in the next major cabal-install release. For a large project like pandoc (including all of its dependencies) we measure a 10% (std.dev. 0.6pp) reduction in wall clock time for a 16-way parallel build with --semaphore. No user changes are needed to take advantage of this improvement.

History: `Cabal` and `cabal-install`

The genesis: the `Cabal` specification

First, there was Cabal. Its design was laid out in A Common Architecture for Building Applications and Tools. Fundamentally, it defines the notion of a package, with each package being built and installed with the following sequence of commands:

> hc Setup.hs
> ./Setup configure
> ./Setup build
> ./Setup install

Each package must be built in dependency order, with hc-pkg registering each installed library into a package database.

Orchestrating the build of multiple packages

cabal-install was then born to plan and execute a build plan consisting of many packages. With its solver, it determines a build plan, which is then orchestrated by running the above sequence of commands for each package, in dependency order.

There is however one architectural mismatch: for the solver to be able to compute a build plan, it already needs a lot of information about the current system:

What Haskell compiler are we using?
What system libraries are available (pkgconfig-depends)?
What build tools are available (build-tool-depends)?

This means that cabal-install already has in its hands most of the information necessary for configuring a package; in particular it has already resolved all the conditionals in every package description. We should thus be able to skip most of the steps in the package’s ./Setup configure phase. However, the command-line interface of ./Setup configure makes it practically impossible to do so: passing a fully resolved dependency graph would require many additions to the already bloated ConfigFlags datatype, and a lot more data being serialised/deserialised.

Because of this limitation, cabal-install’s approach was to take its hard-won build plan and convert it into ConfigFlags that specify exact dependency versions and flag assignments. This amounts to passing ./Setup configure an already fully constrained configuration; the configure step would then re-probe the system, re-read package databases… only to re-discover exactly what cabal-install already knew!

A new architecture for `cabal-install`

The paradigm shift proposed in our Sovereign Tech Fund proposal is that cabal-install should be responsible for orchestrating the whole build process instead of running the conceptually independent build systems provided by each package. With cabal-install now in control, it can directly call Cabal library functions, which in turn allows skipping steps in the configure phase that waste time re-discovering information that cabal-install is already aware of.

To implement such a change, we first needed to prepare the terrain: when invoking an external executable such as the Setup executable – say via the process library as Cabal uses – we can set the working directory, environment variables and redirect input/output handles. It was not possible to do this directly via the Cabal library, so we first needed to add Cabal library support for setting the working directory and for choosing logging handles. Once this was done, it allowed us to refactor cabal-install to directly call Cabal library functions to build packages.

Performance impact

This architectural change provides a solid foundation for further improvements. The two main time sinks in the Cabal configure phase were determined to be (using a new --build-timings flag to cabal-install):

(~50% of configure time) Re-configuring the compiler program database. The compiler and hc-pkg were already pre-configured, but other programs such as haddock, ar, ld etc were re-configured anew for each package.
(~40% of configure time) Re-probing the installed package database, via hc-pkg dump.

We can skip this extra work by pre-configuring the compiler ProgramDb and keeping a running InstalledPackageIndex. These two changes, taken together, reduce the time spent in the configure phase by over 90%.

While most of the time in builds is unsurprisingly spent… actually compiling Haskell code [citation needed], the impact on full builds is still rather significant. For example, when compiling aeson with -j1, we saw a reduction in total build time of ~16.6% (std.dev. 1.9pp) in our benchmarks.

The fact that the configure phase is inherently serial also means that these improvements have a notable impact when combined with the -jsem feature. This is because the -jsem feature allows us to assign more capabilities to the build phase. As per Amdahl’s law, this results in the configure phase becoming more of a bottleneck. For example, when compiling pandoc with cabal install pandoc -j16 --semaphore, we saw a reduction in total build time of ~10% (std.dev. 0.6pp).

Further improvements

These improvements provide a small glimpse of what is possible after our changes to cabal-install’s architecture. A more ambitious long-term goal would be for cabal-install to manage a “giant build graph” on a finer granularity level than whole Cabal components. For example, if package q depends only on module P1 from package p, we could imagine starting to compile q after compiling P1 but before we have finished compiling the rest of p. This would unlock build-time reductions by increasing available parallelism, and also enable more accurate progress and error reporting.

Theory Lunch (Institute of Cybernetics, Tallinn): A Remarkable Property of Real-Valued Functions on Intervals of the Real Line

Fri, 22 May 2026 15:51:36 +0000

Today the 17 October 2019 I discussed a very remarkable fixed point theorem discovered by the Ukrainian mathematician Oleksandr Micholayovych Sharkovsky.

We recall that a periodic point of period for a function is a point such that . With this definition, a periodic point of period is also periodic of period for every which is a multiple of . If but for every from 1 to , we say that is the least period of .

Theorem 1. (Sharkovsky’s “little” theorem) Let be an interval and a continuous function. If has a point of least period 3, then it has points of arbitrary least period; in particular, it has a fixed point.

Note that no hypothesis is made on being open or closed, bounded or unbounded.

Our proof of Sharkovsky’s “little” theorem follows the one given in (Sternberg, 2010), and could even be given in a Calculus 1 course: the most advanced result will be the intermediate value theorem.

Lemma 1. Let be a compact interval of the real line and a continuous function. Suppose that for some compact interval it is . Then has a fixed point in .

Proof. Let and be the minimum and the maximum of in , respectively. As , it is and . Choose such that and . Then is nonpositive at and nonnegative at . By the intermediate value theorem applied to , must have a fixed point in the closed and bounded interval (possibly reduced to a single point) delimited by and , which is a subset of .

Lemma 2. In the hypotheses of Lemma 1, let be a closed and bounded interval contained in . Then there exists a closed and bounded subinterval of such that .

Proof. Let . We may suppose , otherwise the statement is trivial. Let be the largest such that . Two cases are possible.

There exists such that . Let be the smallest such , and let . Then surely , but if for some we had either or , then by the intermediate value theorem, for some Â we would also have either or , against our choice of and .
for every . Let then be the largest such that , and let . Then for reasons similar to those of the previous point.

Proof of Sharkovsky’s “little” theorem. Let be such that , , and . Up to cycling between these three values and replacing with , we may suppose . Fix a positive integer : we will prove that there exists such that and for every .

Let and be the “left” and “right” side of the closed and bounded interval : then and by the intermediate value theorem. In particular, , and Lemma 1 immediately tells us that has a fixed point in . Also, , so also has a point of period 2 in , again by Lemma 1: call it . This point cannot be a fixed point, because then it would also belong to as , but which has period 3. As we can obviously take , we only need to consider the case .

By Lemma 2, there exists a closed and bounded subinterval of such that . In turn, as , there also exists a closed and bounded subinterval of such that , again by Lemma 2: but then, . By iterating the procedure, we find a sequence of closed and bounded intervals such that, for every , and .

We stop at and recall that : we are still in the situation of Lemma 2, with in the role of . So we choose as a closed and bounded subinterval not of , but of , such that . In turn, as , there exists a closed and bounded subinterval of such that . Following the chain of inclusions we obtain . By Lemma 1, has a fixed point in , which is a periodic point of period for .

Can the least period of for be smaller than ? No, it cannot, for the following reason. If has least period , then so has , and in addition is divisible by . But while for every . Consequently, if has least period , then . But this is impossible, because by construction as , while .

Theorem 1 is a special case of a much more general, and complex, result also due to Sharkovsky. Before stating it, we need to define a special ordering on positive integers.

Definition. The Sharkovsky ordering between positive integers is defined as follows:

Identify the number , with odd integer, with the pair .
Sort the pairs with in lexicographic order.

That is: first, list all the odd numbers larger than 1, in increasing order; then, all the doubles of the odd numbers larger than 1, in increasing order; then, all the quadruples of the odd numbers larger than 1, in increasing order; and so on.

For example, and
Set for every and .

That is: the powers of 2 follow, in the Sharkovskii ordering, any number which has an odd factor.

For example, .
Sort the pairs of the form —i.e., the powers of 2—in reverse order.

The set of positive integer with the Sharkowsky ordering has then the form:

Note that is a total ordering.

Theorem 2. (Sharkovsky’s “great” theorem) Let be an interval on the real line and let be a continuous function.

If has a point of least period , and , then has a point of least period . In particular, if has a periodic point, then it has a fixed point.
For every integer it is possible to choose and so that has a point of minimum period and no points of minimum period for any . In particular, there are functions whose only periodic points are fixed.

Bibliography:

Keith Burns and Boris Hasselblatt. The Sharkovsky theorem: A natural direct proof. The American Mathematical Monthly 118(3) (2011), 229–244. doi:10.4169/amer.math.monthly.118.03.229
Robert L. Devaney, An Introduction to Chaotic Dynamical Systems, Second Edition, Westview Press 2003.
Shlomo Sternberg, Dynamical Systems, Dover 2010.

Haskell Interlude: 82: Fraser Tweedale

Tue, 19 May 2026 12:00:00 +0000

We talked to Fraser Tweedale. Fraser works at Red Hat, and is on the Haskell Security Response Team. We talked about security in the context of Haskell, both technical and organizational issues, and also the political issues involved. Fraser's work is both really important and not well-known in the Haskell ecosystem, so it was high time for him to come on the show.

Gabriella Gonzalez: Type out the code

Tue, 19 May 2026 00:00:00 +0000

Freecoding improves broader programming proficiency

Eric Kidd: Redoubtful: Linux agent sandbox progress

Sun, 17 May 2026 18:50:36 +0000

I’ve also been experimenting with agent sandboxes lately. redoubtful is a work-in-progress sandbox that supports:

Linux-only sandboxes: I’m focusing on what Linux supports, specifically, rather than trying to support the lowest-common-denominator features that work cross platform.
Modular configuration profiles: See below.
Isolation using pasta and bwrap.
A shadow filesystem that looks like your home directory, so things like git worktree actually work correctly. You can also selectively mount existing parts of your filesystem in read-only or read-write mode.
Network port forwarding and filtering proxy server.
TODO: Proxy credential support.

But first, a warning: Nearly 100% of this code was written by coding agents, much of it by a local Qwen3.6 27B. I am, however, keeping a very close eye on the output—one of my goals here is to see just what a small agent like this can do. This is maybe only 80% as good as my handwritten code would be a similar point in a project.

And finally, this is an incomplete work-in-progress, and it has not been packaged nicely for anyone besides me yet.

Modular configuration “profiles”

One of the slightly novel parts of all this is the ability to define modular configuration. This allows us to invoke a sandbox with a specific set of credentials:

redoubtful run --uses pi --uses llama-server pi

Here, we’re running the pi.dev coding agent with a locally-served Qwen3.6 27B via llama-server. Qwen3.6 27B is a fantastic lightweight coding model, and it works very well with pi.dev’s minimalist prompt. And since we’re running in a sandbox, we don’t care that pi.dev provides no sandbox and no confirmation before acting.

To set up these two profiles, we first define a node profile:

# Standard Node setup. If you're using `nvm`, you'll need to fix the path_add
# entry to point to the correct nvm version.
#
# We might want some kind of plugin system to handle messy things like nvm.
[profile.node]
mounts = [
    { host = "~/.npm-global" },
    { host = "~/.local/share/nvm", access = "rw" },
]
path_add = ["~/.npm-global/bin", "~/.local/share/nvm/v24.15.0/bin"]

Then let’s make Rust work:

# A Rust setup, with optional rustup and advisory support.
[profile.rust]
mounts = [
    { host = "~/.rustup" },
    { host = "~/.cargo" },
    # Cargo audit/deny support, which needs to take a lock to update the
    # advisory database.
    { host = "~/.cargo/advisory-dbs/", access = "rw" },
]
path_add = ["~/.cargo/bin"]

And then basic git is easy—we just need enough config to read user.name and user.email:

# Things you will likely want for git.
[profile.git]
mounts = [{ host = "~/.gitconfig" }]

And then finally, we can set up pi itself:

# Profile for the pi coding agent. Run with:
#
#     redoubtful run -u pi pi
[profile.pi]
uses = ["node", "rust", "git"]
mounts = [{ host = "~/.pi", access = "rw" }]

# Pass through llama-server connections.
[profile.llama-server]
forwards = [{ host_port = 8080 }]
proxies = [{ host = "127.0.0.1" }]

What’s left?

The biggest missing piece is teaching the proxy server how to inject real credentials into network connections. This isn’t a new idea. The goal is to provide access to things like GitHub without giving an agent actual credentials.

After that, it’s just packaging everything up nicely and writing some docs, so that other people (or agents) can easily configure it for different purposes.

Eric Kidd: Lab notebook: Edit completion #1

Sat, 16 May 2026 15:49:55 +0000

I continue to be interested in late-2024-era edit completion, the “Fill in the Middle” (FIM) models. You know, what Copilot used to do, back before it started generating “mini diffs.” Why?

I like and use agentic workflows. But as many people are realizing, it’s super easy to lose track of what’s happening in your code, with terrible consequences. So I want to reinvest in human-in-the-loop tools, too. (And slightly weaker agentic models, but more on that later.)
The new-school edit completion offered by Copilot and Zed’s Zeta2 actually slows me down. It overlays diffs on my buffer, which is visually disorienting at speed. And it proposes edits further from the current cursor, which take me longer to mentally process. Personally, the new style feels like hunt-and-peck. The older style felt like really fast touch typing.

Mind you, I’m a very specific sort of user. I want to know how my code works. I want my code to be clean. And I can read a half-page code completion in moments, thanks to way too many years of reading PRs.

Initial experiments

All experiments performed in Zed, which does less post-processing of the raw model output than some tools. All evaluations are purely subjective.

New-school models (generating diffs). Zeta2 is honestly pretty underwhelming right now. The completions are very generic. And Zeta2 seems to be bad about taking the context into account. It will complete a function, sure. But I’d swap Zeta2 for late 2024 Copilot in a heartbeat.

Old-school models (FIM, inserting at cursor). Let’s go down the list so far:

ggml-org/Qwen2.5-Coder-7B-Q8_0-GGUF:Q8_0: The classic, default choice. This isn’t terrible, and it gives more context-aware completions than Zeta2. But it’s generations old, and I want to know if anything is new and shiny.
mradermacher/Seed-Coder-8B-Base-i1-GGUF:Q6_K. This is the raw base that went into Zeta2, I think? It doesn’t seem to be useful in Zed, because the inserted text feels pretty raw. This might work better in a smarter harness. But I’m dropping it for now.
JetBrains/Mellum-4b-base-gguf:Q8_0. Downloaded, but not yet tested.
unsloth/Qwen3.6-35B-A3B-GGUF:IQ4_XS. This is unexpectedly good! Worth further experimentation.

Refining Qwen3.6 35B A3B: Changing order from PSM to SPM

Qwen typically uses FIM, “Fill in the Middle” completion. This uses 3 magic tokens:

/// Qwen FIM prefix marker.
const PRE: &str = "<|fim_prefix|>";
/// Qwen FIM suffix marker.
const SUF: &str = "<|fim_suffix|>";
/// Qwen FIM middle marker (model generates after this).
const MID: &str = "<|fim_middle|>";

We have two possible flavors. The original is “PSM” compeletion, “prefix, suffix, middle”:

{PRE}{prefix}{SUF}{suffix}{MID}

But since the prefix grows with each keystroke, we can’t cache the entire message. We could get much better caching with “SPM” order:

{SUF}{suffix}{PRE}{prefix}{MID}

Here, we can cache everything up to the final {MID} character, and resume generation with a longer prefix. Whooo, speed!

But Zed doesn’t support SPM completion, only PSM. So I fired up a copy of Claude Code (as one does), and asked, “Hey, write me a Rust proxy server (using my standard conventions) that intercepts /completion, and translates PSM to SPM please.”

Results: Extremely disappointing. SPM format confuses Qwen3.6 35B A3B pretty badly. But then I thought, “Hey, even if we’re running in /completion mode, this is still an instruction-tuned model. Can we prompt it?” One unscientific tweak later:

You are a code-completion tool. You receive input in
fim_suffix+fim_prefix+fim_middle order, and your job
is to generate what the user would be likely to type
next. When in doubt, keep it short. Think of this like
generating a diff in agentic coding mode. You're trying
to insert the right text to make a working program that
does what the user wants. If there's no obvious next
step, generate nothing.

{SUF}{suffix}{PRE}{prefix}{MID}

This is still pretty bad, but it’s better. You can tell it’s trying to be an SPM autocompleter, though it’s still the worst of the bunch.

Possible next steps:

What if we modify the proxy to transform /completion into a /chat/completions request, with a real prompt, real text inputs, and tool for insert_at_cursor(text)? Can we access more of the model’s intelligence?
Qwen3.6 35B A3B is small enough to fine-tune! We could look up file completion data sets, and try to create a LoRA adapter. We could even use something like tree-sitter to generate custom completion examples. Would that give us something useful?

I also notice that FIM-style models are notoriously bad at choosing a good stopping place. This can be fixed with a lot of regexes. But what if our fine-tuning data took care to demonstrate good stopping places?

Oskar Wickström: Coding on Paper

Fri, 15 May 2026 22:00:00 +0000

About three months ago, I bought the Onyx BOOX 25.3” Mira Pro Color, an e-ink monitor for desktop use. I’ve used it as my primary monitor since, and I’ve had a lot of questions about it. This is my experience report, from the perspective of a working, still mostly typing, programmer.

This is not a sponsored post, and it is not a product review. I wrote a very similar post about the Daylight DC-1 last year.

Neovim in the morning sunlight.

As explained in last year’s post, the reason I persist with these monitors is because it makes me energetic and happy. Sunlight, direct or indirect, helps me stay clear and focused during my workday. I find spaces illuminated by natural light beautiful and inspiring.

I’m not going to recommend that you buy one of these devices. They’re expensive, about $2000, and the experience is quite different from LCD. Even if this looks cool, it seems to me very possible that most people would not like it in practice. With that said, I am happy with it, and I’ll probably keep investing in these tools as they get even better with time.

Spending a workday in the garden.

Using the Mira Pro as a primary monitor is a continuation of the experiments with my e-ink tablets and Termux as coding environments. But now, with far fewer compromises. I’m running my regular NixOS environment on my work laptop. No SSH and tmux needed, no Android terminal emulator to customize.

What I have done, though, is spent quite some time on making my system more suited for this monitor. The Mira Pro does not work well with dark themes. In fact, it only works well with high contrast light themes.

Luckily, I’m bent towards minimalism, so I already used near-monochrome themes, relying more on typographic syntax highlighting rather than coloring. I now have custom themes for Neovim, Zed, and Ghostty with a few vivid colors for things like selection, comments, and constants. Otherwise it’s largely black on white.

It’s trickier with other applications. In Firefox, I’ve started using the high contrast setting. That works pretty much like an inverse of DarkReader. I now run Spotify in the browser in order to avoid its dark theme.

The monitor has a clunky menu system with which you can change rendering modes; things like contrast and speed. I found an open-source reverse-engineered NodeJS package that I use with Hyprland keybindings to easily change rendering modes and manually refresh. No need for the built-in menu.

In practice I use two modes:

Reading:: This mode renders colors most vividly and text sharply, but typing with it is agony. I use it when reading text documents, web pages, or code diffs.
Writing:: This is by far the most commonly used mode, which compromises colors and sharpness for way better latency. I use this for everything in the terminal, chat, general web browsing, and probably most other things not covered by the reading mode.

See the following photos for a close-up comparison:

Reading mode, where colored regions are pretty smooth and text looks sharp.

Writing mode, where colored regions (light gray, red, green) are grainy and text is a bit blurry.

What about latency? Here’s the two short clips of me typing with the reading and writing modes:

Reading mode, with horrible latency for typing.

Writing mode, with some but acceptable latency.

Ghosting? In my writing mode it’s minimal. It really doesn’t bother me.

About the color panel: I don’t like it very much to be honest. It was the only version of the Mira Pro available from the Swedish retailer at the time, so I went with it. I think I would’ve been happier with a monochrome panel, because the coloring technology makes it considerably darker.

Here’s a comparison between the Palma 2 Pro (using a similar but smaller Kaleido color panel) and my old Tab Ultra (with a monochrome panel):

Color vs Monochrome e-ink panels without backlight.

Unless the room has great diffuse lighting, natural or otherwise, the color panel does require some backlight. In direct sunlight or outdoors it works without. I might spend more time optimizing the lighting in my office to make this work during the winter months.

So, what’s to make of it? Personally, I enjoy using this monitor a lot, even if it’s not perfect. Should you buy an expensive 25” e-ink monitor? I cannot say. But if you do, let me know how it works out.

My custom themes and keybindings can be found here.

Eric Kidd: I should blog more

Wed, 13 May 2026 05:04:52 +0000

This blog is ancient, in blog years. The first post was on June 30, 1998, and it featured a randomized emboss for MathMap. Back in those days, it was a mix of neat little snippets like that and interesting links. The site was a single, hand-edited HTML file in reverse chronological order. It ran on a Linux mini-tower built from parts from the MIT Swapfest, and it lived under my desk.

Google hadn’t been incoporated yet. The Internet bubble was still inflating.

Over the years, the tech stack changed: for a while, this site used SGML-based rendering via a custom script (or was it XML?), then it was a nice interactive Typo site with comments, and then eventually it migrated to the current Jekyll architecture. Which seems to be about 12 years old. I’m pretty proud to have kept nearly all the inbound links working for decades now.

Around 2007 or so, I did a fun series of high effort posts about probability monads. But high-effort posts are a trap. Soon I started feeling like every post ought to be high effort. And then I wrote less and less.

But blogs are a bit of a retro endeavour these days. RSS readers still exist, but I imagine nearly all my subscribers have disappeared since the heady days of 2007. And apparently it’s trendy to work with the garage door up.

So maybe it’s time to get back this site’s roots. I don’t have any MathMap snippets for you today, sadly, because the last release seems to have been in 2004. But here’s a cool trick!

Eric Kidd: Edit completion works with Qwen3.6 35B A3B!

Wed, 13 May 2026 05:04:52 +0000

Do you miss the old-style Copilot completions? The ones where it inserted grey text at the cursor? There’s an open version of this called “FIM completion”. And the classic model for doing this is Qwen2.5 Coder 7B.

But it turns out that Qwen3.6 35B A3B is can also do autocompletion! The fact that it has 3B active parameters means that it’s fast. And the 35B total parameters means it’s smarter than the smaller models.

So let’s fire it up using llama-server:

llama-server -hf unsloth/Qwen3.6-35B-A3B-GGUF:UD-IQ4_XS \
    --cache-type-k q8_0 --cache-type-v q8_0 --no-mmproj \
    --ctx-size 4000

--no-mmproj says to disable the vision mode. --cache-type-k q8_0 --cache-type-v q8_0 reduces the cache precision, since we’re not really using the cache. You might also need to grab a smaller quant, depending on your available VRAM.

Then, we can configure it using Zed:

{
  "edit_predictions": {
    "provider": "open_ai_compatible_api",
    "open_ai_compatible_api": {
      "api_url": "http://localhost:8080/v1/completions",
      "model": "unsloth/Qwen3.6-35B-A3B-GGUF:IQ4_XS",
      "prompt_format": "qwen",
      "max_output_tokens": 256,
    },
  },
}

So how good is this? Well, the completions aren’t too bad at all, but Zed doesn’t seem to do much post-processing. So the completions to be too long. At lot of this could likely be improved with a proxy that did some pre- and post-processing, and maybe a bit of fine tuning.

But this is an actual, working, 100% local autocomplete. And it’s close to being actually good.

Oskar Wickström: Catching Typos on My Website with Browser Testing

Tue, 12 May 2026 22:00:00 +0000

One neat thing about Bombadil’s specification language is that it’s plain TypeScript, with access to external NPM packages. I’ve written a specification that spell-checks my website — what you’re reading now — and I want to share how that turned out.

The inner loop (spell-checking):

Bombadil randomly walks the website and collects misspelled words as property violations. The specification uses nspell with American and British English dictionaries and a personal word list in the repository. This is fast and strict.

The outer loop (triage):

I’m running Claude Code with a spell-checking skill, a triage loop that goes something like this:

Run Bombadil against the local development server for 5 minutes and capture the output. If no words flagged, we’re done.
Collect each flagged word and the URL it appeared on.
Triage each word into one of these buckets:
- Real typo: fix the markdown source
- Legitimate common word: add to the custom dictionary
- Legitimate uncommon or very technical word: mark inline with spellcheck="false"
- Extraction noise: add a unit test and fix the word extractor
Run Bombadil against each failing URL to confirm the corrections.
Go to step 1.

This is slow and loose.

The hybrid model seems to work well; it has flagged words in almost every blog post. It has fixed 13 real typos and added 130+ words to my personal dictionary. Example typos include “forseeable”, “similiar”, “perculiar”, “occured”. Some of these were 10 years old.

Claude doesn’t have to waste tokens spell-checking everything over and over. Right now I’m just running this locally, but you could imagine a more elaborate setup for large websites where the “inner loop” runs as a nightly job, invoking the “outer loop” only on violations. You could involve a human where needed, and build up a domain-specific dictionary over time.

Note that using an LLM is entirely optional. It just saves me some time. You can do triage on your own.

Why not spell-check the sources directly? Yes, that is often preferable, and I use spell in Neovim all the time. But it’s not always practical. At least in my experience, the tooling trips up on syntax and templating in more complicated setups. Maybe your editor handles this better than mine does, or maybe you’re fine with tools like typos and codespell, but I like the fact that this approach is external and checks the rendered output. Given that Bombadil interacts with web applications, you could even run this against dynamic applications to spell-check states deep in the UI.

Speaking of source-level checking: since the custom dictionary is a plain word list, I point Neovim’s spellfile at it and use zg to add words while I edit. A single source of truth that both tools write to.

vim.opt.spellfile = "/path/to/custom.utf-8.add" vim.opt.spelllang = "en"

Being able to use NPM packages in specifications has turned out to be more useful than I expected. In addition to nspell, I’m using tlds to identify URLs. Bombadil is built for property-based testing of web applications, but with a specification language and package ecosystem at hand, its uses might be broader than my original vision.

If you’re interested in setting up something like this on your own, you’ll find the sources in my Bombadil playground.

Disclosure: I’m the original author and lead for the Bombadil project at Antithesis.

Well-Typed.Com: Exception Annotations: Lay of the Land

Fri, 08 May 2026 00:00:00 +0000

Exception annotations were introduced in GHC 9.10, and can be an invaluable tool for debugging thorny problems. The initial implementation had some important limitations that made them less useful in practice than one might hope, but fortunately the situation has since been much improved. In this blog post we will give a detailed overview of the status quo as of GHC 9.12/9.14, identify some gotchas you should be aware and provide advise on how to deal with them, and briefly look ahead to what will change in GHC 10.0. We will also dedicate a section to discussing the problems in GHC 9.10, for those who cannot yet upgrade.

Although we will recap all necessary definitions, this blog is not meant to be an introduction to exception annotations; if you have never used them before, you might first want to watch The Haskell Unfolder Episode 29: exceptions, annotations and backtraces.

Backtraces

Before we look at the general framework for exception annotations, let’s first briefly recap the concept of backtraces, which is GHC’s answer to stack traces in other languages. The situation is more complicated in Haskell due laziness, and there are actually four different kinds of backtraces:

based on HasCallStack annotations
based on cost-centres (which will require compiling your program with profiling enabled)
based on IPE info
based on DWARF info

In this blog post we will use the first two only, but for the purposes of our main discussion here the choice actually does not matter much; see GHC proposal Decorate exceptions with backtrace information for details. If you’re interested in IPE backtraces specifically, you might also be interested in our blog post Better Haskell stack traces via user annotations, which discusses some recent extensions we implemented to improve these.

`HasCallStack` backtraces

Consider this simple Haskell program, where main calls top calls middle calls bottom:

bottom :: HasCallStack => IO ()
bottom = do
    bt <- collectBacktraces
    putStrLn $ displayBacktraces bt

middle :: HasCallStack => IO ()
middle = bottom

top :: HasCallStack => IO ()
top = middle

main :: IO ()
main = top

A HasCallStack is essentially an additional function argument which is automatically populated by GHC at call sites with information about where the function was called. When we run this program, we see something like this:

HasCallStack backtrace:
  collectBacktraces, called at exe/DemoCallStack.hs:13:11 in (..)
  bottom, called at exe/DemoCallStack.hs:18:10 in (..)
  middle, called at exe/DemoCallStack.hs:22:7 in (..)
  top, called at exe/DemoCallStack.hs:25:8 in (..)

The only thing worth noting here is that the moment a HasCallStack chain is broken, the backtrace is cut off there. For example, if middle does not have a HasCallStack constraint, we can no longer see where middle was called from:

HasCallStack backtrace:
  collectBacktraces, called at exe/DemoCallStack.hs:19:11 in (..)
  bottom, called at exe/DemoCallStack.hs:24:10 in (..)

The fact that top still has a HasCallStack constraint does not matter: the callstack is cut at the first missing link.

Cost centre backtraces

Cost centres are how GHC implements profiling: very roughly, the cost of a computation is attributed to its enclosing cost centre (see chapter Profiling of the GHC manual). Like HasCallStack, this relies on source code annotations:

{-# SCC bottom #-}
bottom :: HasCallStack => IO ()
bottom = do
    bt <- collectBacktraces
    putStrLn $ displayBacktraces bt

{-# SCC middle #-}
middle :: IO ()
middle = bottom

{-# SCC top #-}
top :: HasCallStack => IO ()
top = middle

{-# SCC main #-}
main :: IO ()
main = do
    setBacktraceMechanismState CostCentreBacktrace True
    top

Unlike HasCallStack, however, GHC offers ways for inserting such annotations automatically, which can often make cost centre based callstacks more practical than HasCallStack. The most common flag to do this is -fprof-auto or (in recent GHC) -fprof-late (see Late Cost Centre Profiling). This inserts cost centres around all top-level functions, as we did manually above.

Cost centre backtraces must be explicitly enabled by calling setBacktraceMechanismState, and you need to compile your code with profiling enabled; the cabal option --enable-profiling both enables profiling as well as automatic cost centre insertion. The backtrace for this example might look something like

Cost-centre stack backtrace:
  DemoCallStack.main (exe/DemoCallStack.hs:(32,1)-(34,7))
  DemoCallStack.top (exe/DemoCallStack.hs:28:1-12)
  DemoCallStack.middle (exe/DemoCallStack.hs:24:1-15)
  DemoCallStack.bottom (exe/DemoCallStack.hs:(18,1)-(20,35))

Be aware however that optimizations can delete cost centres, especially in simple examples like this (#27225).

Cost centres vs exception handling

Consider the following example: as before, main calls top calls middle calls bottom, which prints a backtrace; however bottom then throws an excepton. Meanwhile, main installs an exception handler called handlerTop, which in turn calls handlerMiddle calls handlerBottom, which prints its own backtrace:

bottom :: HasCallStack => IO ()
bottom = do
    bt <- collectBacktraces
    putStrLn $ displayBacktraces bt
    throwIO $ userError "Uhoh"

middle :: HasCallStack => IO ()
middle = bottom

top :: HasCallStack => IO ()
top = middle

handlerBottom :: HasCallStack => SomeException -> IO ()
handlerBottom _e = do
    bt <- collectBacktraces
    putStrLn $ displayBacktraces bt

handlerMiddle :: HasCallStack => SomeException -> IO ()
handlerMiddle e = handlerBottom e

handlerTop :: HasCallStack => SomeException -> IO ()
handlerTop e = handlerMiddle e

main :: IO ()
main = do
    setBacktraceMechanismState CostCentreBacktrace True
    top  `catch` handlerTop

The HasCallStack backtrace printed by bottom is

HasCallStack backtrace:
  collectBacktraces, called at exe/DemoCCS.hs:24:11 in (..)
  bottom, called at exe/DemoCCS.hs:29:10 in (..)
  middle, called at exe/DemoCCS.hs:32:7 in (..)
  top, called at exe/DemoCCS.hs:41:5 in (..)

as before; the HasCallStack printed by handlerBottom is very similar:

HasCallStack backtrace:
  collectBacktraces, called at exe/DemoCCS.hs:13:11 in (..)
  handlerBottom, called at exe/DemoCCS.hs:17:19 in (..)
  handlerMiddle, called at exe/DemoCCS.hs:20:16 in (..)
  handlerTop, called at exe/DemoCCS.hs:41:18 in (..)

For the cost-centre based backtrace, the one shown in bottom is as before:

Cost-centre stack backtrace:
  DemoCCS.main (exe/DemoCCS.hs:(39,1)-(41,27))
  DemoCCS.top (exe/DemoCCS.hs:32:1-12)
  DemoCCS.middle (exe/DemoCCS.hs:29:1-15)
  DemoCCS.bottom (exe/DemoCCS.hs:(23,1)-(26,30))

but the one shown in handlerBottom is more surprising:

Cost-centre stack backtrace:
  DemoCCS.main (exe/DemoCCS.hs:(39,1)-(41,27))
  DemoCCS.top (exe/DemoCCS.hs:32:1-12)
  DemoCCS.middle (exe/DemoCCS.hs:29:1-15)
  DemoCCS.bottom (exe/DemoCCS.hs:(23,1)-(26,30))
  DemoCCS.handlerTop (exe/DemoCCS.hs:20:1-30)
  DemoCCS.handlerMiddle (exe/DemoCCS.hs:17:1-33)
  DemoCCS.handlerBottom (exe/DemoCCS.hs:(12,1)-(14,35))

Whether or not this is expected/correct behaviour is arguable, but the rule is this: the cost centre stack is not restored until we leave the scope of catch. Put another way: the cost centre stack reflects the fact that bottom “calls” handlerTop, however indirectly. This applies transitively: if handlerTop would throw an exception, which would then be caught by some other exception handler, then its backtrace would reflect that top “called” handlerTop “called” that other exception handler. This kind of situation can arise quite naturally, for example when using handlers that deallocate some resources and then rethrow the exception.

Basic definitions

Before we look at the subtleties that arise from actually catching and throwing (or rethrowing) exceptions, we’ll first get the basic definitions out of the way. These have not changed much between recent GHC versions and are hopefully uncontroversial.

Exception annotations

Exceptions annotations can basically be anything at all; the only requirement is that that we can display them:

class Typeable a => ExceptionAnnotation a where
  displayExceptionAnnotation :: a -> String

An important instance of this class is Backtraces, which wraps a set of different kinds of backtraces:

instance ExceptionAnnotation Backtraces where
    displayExceptionAnnotation = Base.displayBacktraces

Exception context

An exception context is essentially just a list of exception annotations. However, since those annotations may be of different types, we need to wrap them in an existential:

data ExceptionContext = ExceptionContext [SomeExceptionAnnotation]
data SomeExceptionAnnotation = forall a. ExceptionAnnotation a => SomeExceptionAnnotation a

There are functions for manipulating the exception context. The most important are emptyExceptionContext and addExceptionAnnotation, for creating an empty context and inserting an annotation into an existing context respectively.

emptyExceptionContext  :: ExceptionContext
addExceptionAnnotation :: ExceptionAnnotation a => a -> ExceptionContext -> ExceptionContext

Pivotal change: `SomeException`

The pivotal change in all of this is in the definition of SomeException which, starting in GHC 9.10, now has an associated list of annotations:

data SomeException = forall e. (Exception e, HasExceptionContext) => SomeException e
type HasExceptionContext = (?exceptionContext :: ExceptionContext)

The use of an implicit parameter means that pattern matching on SomeException remains possible in the same way as before (though the annotations would be silently dropped).

There are various functions for extracting and manipulating the exception context associated with an exception, such as someExceptionContext and addExceptionContext:

someExceptionContext :: SomeException -> ExceptionContext
addExceptionContext  :: ExceptionAnnotation a => a -> SomeException -> SomeException

However, probably the most important function for extending exception contexts is annotateIO, which installs an exception handler that extends any exception that is thrown with the specified annotation:

annotateIO :: forall e a. ExceptionAnnotation e => e -> IO a -> IO a
annotateIO ann (IO io) = IO (PrimOp.catch# io handler)
  where
    handler se = PrimOp.raiseIO# (addExceptionContext ann se)

It is important to emphasize that this is implemented with primops, not with the regular catch and throwIO functions, which do considerably more than merely catching and throwing, as we shall see.

`Exception` type class

The Exception type class is a central abstraction in Haskell’s exception ecosystem. As part of the exception annotation work, it has received one minor extension, and it was changed in two not-so-minor-but-rather-subtle ways. Let’s first get the part out of the way which has not changed: exceptions are no good if we cannot see them:

class (Typeable e, Show e) => Exception e where
  displayException :: e -> String
  displayException = show

  -- (..)

`backtraceDesired`

The minor extension is a new function called backtraceDesired, which indicates if a backtrace should be attached to exceptions of this type; we will see how this function is used when we discuss the implementation of throwIO.

class (Typeable e, Show e) => Exception e where
  -- (..)

  backtraceDesired :: e -> Bool
  backtraceDesired _ = True

The argument to backtraceDesired is already fully constructed exception; the question is whether a backtrace should be added to that exception. In most cases the argument can simply be ignored, but it doesn’t have to be. For all but a handful of specialized cases the default implementation (indicating that yes, we want a backtrace) will be fine.

`fromException`

The not-so-minor-but-rather-subtle changes are in fromException and toException, which remove and add the SomeException wrapper around exceptions respectively. Let’s first look at fromException:

class (Typeable e, Show e) => Exception e where
  -- (..)

  fromException :: SomeException -> Maybe e
  fromException (SomeException e) = cast e

This may look no different from the implementation prior to 9.10, but recall that SomeException now has an additional field: the exception annotations. As mentioned above, a pattern match like this will silently discard those annotations.

`toException`

The final function in the Exception class is toException, which is intended to add the SomeException wrapper.

class (Typeable e, Show e) => Exception e where
  -- (..)
  toException :: e -> SomeException

Prior to 9.10, the default implementation literally just added the SomeException constructor:

  -- implementation prior to 9.10
  toException = SomeException

However, starting in 9.10 we also need to give an initial value for the exception context. The default implementation, reasonably enough, chooses the empty context:

  -- implementation in 9.10, 9.12, 9.14, and 10.0
  toException e = let ?exceptionContext = emptyExceptionContext in SomeException e

Unfortunately, however, the documentation of toException has also been modified, and now states that toException should produce a SomeException with no attached ExceptionContext. Personally, I think that is a mistake (#27194); we will discuss this in the next session.

⚠️ Caution: Instance for `SomeException` itself

SomeException itself is also an instance of Exception; fromException is trivial, and backtraceDesired and displayException piggy-back on the definition of whatever exception is wrapped:

instance Exception SomeException where
  fromException = Just

  backtraceDesired (SomeException e) = backtraceDesired e
  displayException (SomeException e) = displayException e

  -- (..)

The definition of toException is more problematic, however. Prior to 9.10, calling toException on SomeException was just an identity:

instance Exception SomeException where
  -- (..)

  -- Prior to 9.10
  toException se = se

Now, however, the implementation must clear the existing context in order to satisfy the contract:

instance Exception SomeException where
  -- (..)

  toException (SomeException e) = let ?exceptionContext = emptyExceptionContext in SomeException e

I think this is simply wrong; at the very least, it is highly counter-intuitive, and it also does not match the original proposal; I don’t know why this was changed. We will see some consequences of this design choice when we discuss throwing exceptions.

Newtype helpers

There are two auxiliary types, with their own Exception instances, that can be helpful when throwing or catching exceptions in specific ways. We haven’t discussed either throwing or catching yet, but we will nonetheless discuss these auxiliary types first as we will need them in the subsequent sessions.

`NoBacktrace`

NoBacktrace can be used to override backtraceDesired:

newtype NoBacktrace e = NoBacktrace e

instance Exception e => Exception (NoBacktrace e) where
  fromException = fmap NoBacktrace . fromException
  toException (NoBacktrace e) = toException e
  backtraceDesired _ = False
  -- displayException left at its default implementation

`ExceptionWithContext`

The other, arguably more imporant, auxiliary type is ExceptionWithContext. The definition itself is straight-forward: it simply pairs some value with an exception context:

data ExceptionWithContext a = ExceptionWithContext ExceptionContext a

The idea is that this type gives us a way to catch exceptions of specific types (rather than catching SomeException), and still get access to the exception context. For example:

data MyException = MyException
  deriving stock (Show)
  deriving anyclass (Exception)

example :: IO ()
example = someAction `catch` \(ExceptionWithContext ctxt MyException) -> do
    -- (..)

The implementation is reasonably straight-forward:

instance Exception a => Exception (ExceptionWithContext a) where
    toException (ExceptionWithContext ctxt e) =
        case toException e of
          SomeException c ->
            let ?exceptionContext = ctxt
            in SomeException c

    fromException se = do
        e <- fromException se
        return (ExceptionWithContext (someExceptionContext se) e)

    backtraceDesired (ExceptionWithContext _ e) = backtraceDesired e
    displayException = displayException . toException

That said, the devil is very much in the detail with these kinds of definitions, and as we shall see, it was defined incorrectly in GHC 9.10.

Throw

The primary function for throwing an exception is throwIO, which is defined as¹

throwIO :: (HasCallStack, Exception e) => e -> IO a
throwIO e = do
    se <- toExceptionWithBacktrace e
    IO (PrimOp.raiseIO# se)

Most of the actual work happens in toExceptionWithBacktrace:

toExceptionWithBacktrace :: (HasCallStack, Exception e) => e -> IO SomeException
toExceptionWithBacktrace e =
    if backtraceDesired e then do
      bt <- Base.collectBacktraces
      return (addExceptionContext bt (toException e))
    else
      return (toException e)

That is, if a backtrace is desired, we collect one and add it as an annotation to the exception that we’re about to throw.

Generalization

In GHC 9.14 toExceptionWithBacktrace was generalized to

toExceptionWithBacktrace :: (HasCallStack, Exception e) => e -> IO SomeException
toExceptionWithBacktrace e =
    if backtraceDesired e then do
      SomeExceptionAnnotation ea <- collectExceptionAnnotation
      return (addExceptionContext ea (toException e))
    else
      return (toException e)

This is an experimental API (not yet part of base); see CLC #348 for details. The idea is that you can use setCollectExceptionAnnotation to register your own function to be run to construct an annotation whenever an exception is thrown anywhere. For example, if you’re worried that some IO faults are happening due to your CPU overheating, you might use

newtype Temperature = Temperature Int
  deriving stock (Show)
  deriving anyclass (ExceptionAnnotation)

getTempCPU :: IO Temperature
getTempCPU = -- (..)

main :: IO ()
main = do
    setCollectExceptionAnnotation getTempCPU
    -- (..)

By default, the collection callback is collectBacktraces, so unless you register a different callback the behaviour is the same as in 9.10 and 9.12.

⚠️ Caution: Throwing `SomeException`

Because throwIO calls toException, and since toException for SomeException clears the exception context, you probably don’t want to call throwIO on an argument of type SomeException: any exception annotations that might be embedded in that exception will be lost.

The most common case for throwing SomeException is inside an exception handler; we will cover this specific case of rethrowing exceptions when we discuss onException, but we can reuse the same combinators also to define a general “throw precisely this exception” function:

raiseIO :: SomeException -> IO ()
raiseIO (SomeException e) = rethrowIO (ExceptionWithContext ?exceptionContext e)

Catch

The most important change in GHC 9.12 from 9.10 is in the definition of catch, which now implements the WhileHandling proposal. The idea is that when we throw a new exception while handling another, we annotate that new exception with the old exception: the new exception arose while handling the old exception:

data WhileHandling = WhileHandling SomeException deriving Show

catch :: Exception e => IO a -> (e -> IO a) -> IO a
catch (IO io) handler = IO $ PrimOp.catch# io handler'
  where
    handler' se =
      case fromException se of
        Just e' -> PrimOp.catch# (unIO (handler e')) (handler'' se)
        Nothing -> PrimOp.raiseIO# se

    handler'' se se' = PrimOp.raiseIO# (addExceptionContext (WhileHandling se) se')

⚠️ Caution: Rethrowing the same exception

An important combinator for dealing with exceptions is onException, which runs some specified action when an exception occurs (typically some resource cleanup) and then rethrows the exception again:

onException :: IO a -> IO b -> IO a
onException io what = io `catch` \e -> do
    _ <- what
    throwIO (e :: SomeException)

As written, this is suboptimal: for every layer of onException, we re-throw the annotation stripped from its original annotations (due to throwIO and toException for SomeException), and with a new WhileHandling annotation with the original exception (due to catch). This result in unnecessary noise: all the information is still there, but it’s buried. When we rethrow the same exception, there is no need for WhileHanding: we should just throw the original exception as-is.

To solve this, base now offers new functions specifically to catch-and-rethrow: catchNoPropagate² is like the old catch, without the handler that adds the WhileHandling annotation; and rethrowIO, which avoids adding a backtrace (using NoBacktrace; moreover, both of these explicitly preserve contexts (using ExceptionWithContext):

catchNoPropagate :: Exception e => IO a -> (ExceptionWithContext e -> IO a) -> IO a
catchNoPropagate (IO io) handler = IO $ PrimOp.catch# io handler'
  where
    handler' se =
      case fromException se of
        Just e' -> unIO (handler e')
        Nothing -> PrimOp.raiseIO# se

rethrowIO :: Exception e => ExceptionWithContext e -> IO a
rethrowIO e = throwIO (NoBacktrace e)

This then enables the following improved implementation of onException:

onException :: IO a -> IO b -> IO a
onException io what = io `catchNoPropagate` \e -> do
    _ <- what
    rethrowIO (e :: ExceptionWithContext SomeException)

⚠️ Caution: Displaying exceptions

The final pitfall we need to discuss is displaying exceptions. Usually we call displayException to do so, but this does not show annotations. The idea is that displayException is meant to render an exception for users, not necessarily developers.³ Starting withGHC 9.14 there is a separate function displayExceptionWithInfo, but that is not available in GHC 9.12; moreover, even in GHC 9.14 I would advise against using it when you are debugging, as it only shows the top-level annotations, making things like WhileHandling much less useful.

Personally, I like to use my own custom exception handler which shows the full exception, and makes a few other improvements also: it makes the nesting structure clearer, and reorders annotations to improve readability; you can find an example implementation on GitHub .

GHC 9.10

If you cannot upgrade from GHC 9.10, unfortunately the exception annotation infrastructure has some important limitations. Upgrade if you can; if not, this section will explain what you need to be aware of.

Lost annotations

As we remarked when we discussed catch, the WhileHandling proposal only got implemented in GHC 9.12. In GHC 9.10 the definition of catch was still unchanged from its definition before the exception annotation proposal:

catch :: Exception e => IO a -> (e -> IO a) -> IO a
catch (IO io) handler = IO $ PrimOp.catch# io handler'
  where
    handler' se =
      case fromException se of
        Just e' -> unIO (handler e')
        Nothing -> PrimOp.raiseIO# se

However, the Exception instance for SomeException was already changed, so that toException clears the exception context. This means that if an exception with annotations is ever caught and rethrown anywhere, in a pattern such as

someAction `catch` \(e :: SomeException) -> throwIO e

those annotations will be lost. Similarly, since onException had not yet been changed either, any call to onException, and by implificationbracket, anywhere in your callstack would also lose any annotations:

bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket before after thing =
    mask $ \restore -> do
      a <- before
      r <- restore (thing a) `onException` after a
      _ <- after a
      return r

onException :: IO a -> IO b -> IO a
onException io what = io `catch` \e -> do
    _ <- what
    throwIO (e :: SomeException)

In both cases, throwIO will insert a new backtrace, but that backtrace will point to where the exception was rethrown, not to where it was thrown originally. What’s worse, neither bracket nor onException have a HasCallStack constraint, so all we see in the callstack is the call to throwIO from onException itself.

Cost centre stacks do help a bit here (provided you enable profiling): at least you’ll get to see the full backtrace to the exception handler, and with a bit of luck even to the original call to throw, due to the semantics of semantics of cost centres in exception handlers. That won’t always be the case though (for example, in the case of asynchronous exceptions), and you won’t see any of the additional annotations that might have been added to the exception.

Duplicated annotations

The Exception instance for ExceptionWithContext in GHC 9.10 has an incorrect definition for toException:

instance Exception a => Exception (ExceptionWithContext a) where
  -- (..)

  -- implementation in GHC 9.10
  toException (ExceptionWithContext ctxt e) =
      let ?exceptionContext = ctxt in SomeException e

(We saw the correct definition above.)

This is wrong for two reasons:

It does not use toException of the underlying type (the a type parameter); in most cases this does not matter, because toException rarely does anything interesting. Even in the case of SomeException, where toException does something “interesting” (if perhaps ill-advised), to wit clear the exception context, that doesn’t matter here because we are overriding that context anyway. However, there might be types where toException genuinely does something important (even if I am not aware of any such cases currently).
In the specific case that a is SomeException, this will create a nested SomeException: SomeException (SomeException someOtherException) with two copies of the context (the annotations).

The second point here is more important: if we later have exception handlers that manipulate the exception context, they will manipulate the outer context but not the inner. Indeed, if that “manipulation” is “clear the context” (see previous section), we might end up in the somewhat bizarre situation where these two problems cancel out: if we have

someAction `catch` \(ExceptionWithContext ctxt (e :: SomeException))
  throwIO $ ExceptionWithContext ctxt e

then this exception handler will duplicate the annotations, a later exception handler might lose the outermost annotations (previous section) but not the inner, and all of a sudden annotations that were lost mysteriously re-appear; see GHC ticket #27194.

Unfortunately, this is not a viable workaround for the lost annotation problem, as it changes the type of the exception nested in the (outer) SomeException from whatever it really should have been to (the inner) SomeException, which will break any exception handlers for that specific type.

GHC 10.0

The upcoming GHC 10.0 releases makes a few improvements to the exception annotation infrastructure. The first important improvement is that exception handling in STM was lagging behind a bit; this will be rectified (#25365).

The other important fix is in onException. Consider again the definition we saw when we discussed rethrowing exceptions:

onException :: IO a -> IO b -> IO a
onException io what = io `catchNoPropagate` \e -> do
    _ <- what
    rethrowIO (e :: ExceptionWithContext SomeException)

We mentioned that that catchNoPropagate does not install an exception handler that installs a WhileHandling annotation, because we are rethrowing the very same exception. However, if what throws an exception that is no longer the case! The definition of onException is therefore modified to

onException io what = io `catchNoPropagate` \e -> do
    _ <- annotateIO (whileHandling e) what
    rethrowIO (e :: ExceptionWithContext SomeException)

See CLC Proposal #397 for details. As an example, consider what happens if the release callback of bracket itself throws an exception:

data ReleaseFailed = ReleaseFailed
  deriving stock (Show)
  deriving anyclass (Exception)

bottom :: HasCallStack => IO ()
bottom = annotateIO (MyAnnotation 123456789) $ throwIO MyException

middle :: HasCallStack => IO ()
middle = bracket (return ()) (\() -> throwIO ReleaseFailed) $ \() -> bottom

top :: HasCallStack => IO ()
top = middle

With the new definition onException (and my custom exception display function, which is still needed), we get

demo-bracket-release-fail: Uncaught exception of type ReleaseFailed
  ReleaseFailed
  HasCallStack backtrace:
    throwIO, called at exe/DemoBracketReleaseFail.hs:42:38 in (..)
    middle, called at exe/DemoBracketReleaseFail.hs:46:7 in (..)
    top, called at exe/DemoBracketReleaseFail.hs:55:5 in (..)
  WhileHandling
    MyException
      MyException
      MyAnnotation 123456789
      HasCallStack backtrace:
        throwIO, called at exe/DemoBracketReleaseFail.hs:38:48 in (..)
        bottom, called at exe/DemoBracketReleaseFail.hs:42:70 in (..)
        middle, called at exe/DemoBracketReleaseFail.hs:46:7 in (..)
        top, called at exe/DemoBracketReleaseFail.hs:55:5 in (..)

Very nice!

Conclusions

Exception annotations can be invaluable when debugging difficult problems. While the initial implementation in GHC 9.10 had some important limitations, the situation has since been much improved. Provided you use GHC 9.12 or later, there are two things to pay attention to in your own code (these apply to 9.12, 9.14 and 10.0):

Define your own custom function to display exceptions, which shows all annotations, not just the top-level ones (or use mine).
Be cautious with throwing SomeException: toException for SomeException will clear the exception context, which is almost certainly not what you want. For catch-and-rethrow, use the combinators available specifically for that purpose.

That said, there are still a few minor shortcomings to be aware of:

GHC 9.12 and 9.14:
- Exception handling in STM has not yet been updated: throwSTM does not collect a backtrace, and catchSTM does not add any WhileHandling annotations (#25365).
- onException does not add any WhileHandling exceptions; as a result, if the resource deallocation callback to bracket itself throws an exception, the original exception will be lost.
Both of these will be addressed in GHC 10.0.
exceptions-0.10.9: this is the version of exceptions that is bundled with GHC 9.12, but lags behind a bit. For example, the definition of generalBracket in exceptions-0.10.9 does not use any of the abstractions for rethrowing; this is fixed in exceptions-0.10.12. The impact is however limited: it merely means that there are some extraneous WhileHandling annotations, resulting in unnecessary noise.
Any catch-and-rethrow patterns implemented in other packages should not lose any annotations, provided that they use catch from base.

We will ignore calls to withFrozenCallStack, which hide some internal functions from the HasCallStack backtrace. This makes the backtrace slightly more readable, but does not otherwise change anything. See CLC #387.↩︎
Some versions of base distinguish between catchExceptionNoPropagate and catchNoPropagate, which differ only in some strictness annotations. Strictness can make a big difference, especially when IO actions are undefined rather than throwing an exception. However, this is its own can of worms, and outside the scope of this blog post. See CLC proposal #383 for some discussion.↩︎
In GHC 9.10, displayException did show annotaitons, but this got rolled back in 9.12; see CLC #285 for a detailed discussion.↩︎

Oleg Grenrus: Compatibility packages in 2026

Thu, 07 May 2026 00:00:00 +0000

Posted on 2026-05-07 by Oleg Grenrus engineering

Seven years ago I wrote a post about compatibility packages. It is now highly outdated, so let us revisit the matter.

Recently there have been a small push towards reinstallable base. While it's still far from being a thing, it made me remember that using impl(ghc >= 7.9)-like conditionals to guard against different base versions is semantically wrong.

Also recently there is increasing? interest in MicroHs. While I personally don't care about that compiler, I realized that I can make its users experience at least slightly nicer though still somewhat ignoring MicroHs existence.

An example

Luckily there is a solution, and it was around for a long time: automatic flags. Here is a complete example:

flag base-ge-4-16
  description: @base >=4.16@ (GHC-9.2)
  default:     True
  manual:      False

flag base-ge-4-17
  description: @base >=4.17@ (GHC-9.4)
  default:     True
  manual:      False

library
  ...
  build-depends:
      base    >=4.12.0.0 && <4.23

  if !flag(base-ge-4-16)
    build-depends: OneTuple >=0.4.2 && <0.5

  if !flag(base-ge-4-17)
    build-depends: data-array-byte >=0.1.0.1 && <0.2

  if flag(base-ge-4-16)
    build-depends: base >=4.16
  else
    build-depends: base <4.16

  if flag(base-ge-4-17)
    build-depends: base >=4.17
  else
    build-depends: base <4.17

First we declare the flags. I chose to use a naming scheme reminiscing the condition: base-ge-4-17 for base >=4.17.

Then we make the flag selection deterministic:

  if flag(base-ge-4-17)
    build-depends: base >=4.17
  else
    build-depends: base <4.17

Because the base >=4.17 and base <4.17 conditions are disjoint, there is at most one valid flag assignment for any given install plan which includes base - but because base is a direct dependency it has to be in the install plan. This is why I call such flag deterministic¹.

And finally we use the flag value to add a conditional dependency:

  if !flag(base-ge-4-17)
    build-depends: data-array-byte >=0.1.0.1 && <0.2

Previously I would written

  if !impl(ghc >=9.4)
     build-depends: data-array-byte >=0.1.0.1 && <0.2

but as I mentioned in an introduction that is semantically wrong. In this case Data.Array.Byte module is introduced in base-4.17, which just happen to be available in GHC-9.4. In the future there might not be one-to-one correspondence between (major) GHC and base versions.

Moving to use automatic flags removes the direct mention of GHC. This also (hopefully) helps MicroHS users: we don't need to edit

-  if !impl(ghc >=9.4)
+  if !impl(ghc >=9.4) && !impl(mhs)

as there are no direct mention of compilers. The library compatibility conditions are expressed using library version vocabulary.

Low-level tools for high level concept

It is worth mentioning that the three parts: defining the flag, making flag selection deterministic and using the flag value as a condition is indirect way to say something like

if !depends(base >=4.17)
  build-depends: data-array-byte >=0.1.0.1 && <0.2

In other words we use "low-level" tools to express a high level concept.

Maybe some future version of .cabal format would include the high-level way directly. However, the low-level "desugaring" makes it impossible to scrutinize flag selection on indirect dependencies, e.g. we do add dependency to base

  if flag(base-ge-4-17)
    build-depends: base >=4.17

  else
    build-depends: base <4.17

Viewing it from that perspective if a consturct like depends(base >=4.17) is added to .cabal format, it should also add a constraint for install plan to include base, though not necessarily adding it direct dependency. That way the conditional will be deterministic. But such implicit dependency might feel unnatural.

Conclusion

I already rewrote impl(ghc) conditionals to use automatic flags in few packages, and will continue to do that as I'm doing other maintenance tasks.

It seems that OneTuple and data-array-byte are the only few relevant compatibility packages at the moment (using GHC 9); there were a lot of compatibility packages in the last decade (tagged, nats, void, fail, semigroups, bifunctors, contravariant, bifunctor-classes-compat, type-equality, foldable1-classes-compat), but if you don't need to support very old bases & GHCs, we don't need to depend on them for their compatibility shims anymore.

The library part of compatibility story is relatively good, even without having higher level construct like if depends (lib >= x.y) construct. However, the compatibility of language level constructs is lacking. There is no way to ask in .cabal file whether compiler support DeriveGeneric or TemplateHaskell. We can require these extensions, but we cannot ask whether they exist at all. Neither we can differentiate between different versions. Is compiler's ImpredicativeTypes "broken" or not, does LambdaCase include \cases etc. Some part of me wishes the MicroHs a great success, so those issues become more pressing and eventually solved. Solved in some other ways than maintainers hardcoding compiler versions in the package definitions.

In my opinion all automatic flags have to be deterministic. For example having automatic debug flag is IMO just wrong. There are also a bit edge cases related to pkg-config, and I think it's a "bug" in .cabal format that we cannot make pkg-config based library version selection deterministic.↩︎

Magnus Therning: Jumping to errors in Evil

Mon, 04 May 2026 06:16:00 +0000

Recently I realised that it'd be really nice if jumping to errors would store the previous location in the Evil jump list. These definitions do just that

(evil-define-motion mes/evil-goto-next-error (count)
  :jump t
  (unless (bound-and-true-p flymake-mode) (signal 'search-failed nil))
  (flymake-goto-next-error count))
(evil-define-motion mes/evil-goto-prev-error (count)
  :jump t
  (unless (bound-and-true-p flymake-mode) (signal 'search-failed nil))
  (flymake-goto-prev-error count))

and for now I've bound them to C-j and C-k (because that's what evil-collection does)

(general-def flymake-mode-map
  :states 'normal
  "C-j" 'mes/evil-goto-next-error
  "C-k" 'mes/evil-goto-prev-error)

This makes it easier to make a change, fix the errors caused by the change and then return to where I was.

Magnus Therning: Follow-up on switching to eglot

Sat, 02 May 2026 11:20:00 +0000

Jan G sent me a two-part comment.

Part one

I was under the impression that when using elpaca you needed to disable use-package, and that when using elpaca-use-package, you were redefining the macro. Iâ€™m not 100% sure about this, but the documentation has an example of use-package and how it actually expands to an elpaca command.

I wouldn't know. All I can say is that it would be nice if package managers that hook into, or completely redefines use-package, would document if they deviate from the behaviour of "vanilla use-package" in some way.

Part two

Given that, use-packageâ€™s documentation is always going to be a little off, since elpaca is doing everything async. The only way Iâ€™ve found to reliably manage some dependencies is to use the elpaca-after-init hook, so they donâ€™t even try to run until elpaca is finished loading everything.

I'd say it sometimes seems like the documentation for use-package is a little off for use-package itself ðŸ™‚

The README for Elpaca says that

Add configuration which relies on after-init-hook, emacs-startup-hook, etc to elpaca-after-init-hook so it runs after Elpaca has activated all queued packages.

but that seems like a very big hammer and as I understand it I'd have to move the whole :init block for python-mode into the hook in that case. Playing around with the various blocks for use-package isn't too time consuming and I think it's a good first thing to try.

Magnus Therning: Secrets when connecting to DBs

Sat, 02 May 2026 10:41:00 +0000

I should have dealt with comments I got to my posts on how I deal with secrets in my work notes, here, and here. Better late than never though, I hope.

Comment from Stefano R

The first one is a link to post titled How I use :dbconnection in org files. It describes a nice way of setting sql-connection-alist based on the contents of a file, in his case ~/.pgppass.

Comment from Harald J

The other starts with a function for searching ~/.authinfo.gpg for entries of the form

machine <host>/<dbname> login <username> password <password> port <port>

and then setting sql-password-search-wallet-function and sql-password-wallet to tell sql-mode to use it

(defun my/sql-auth-source-search-wallet (wallet product user server database port)
  "Read auth source WALLET to locate the USER secret.
Sets `auth-sources' to WALLET and uses `auth-source-search' to locate the entry.
The DATABASE and SERVER are concatenated with a slash between them as the
host key."
  (when-let (results (auth-source-search :host (concat server "/" database)
                                         :user user
                                         :port (number-to-string port)))
    (when (and (= (length results) 1)
               (plist-member (car results) :secret))
      (plist-get (car results) :secret))))

(setq sql-password-search-wallet-function #'my/sql-auth-source-search-wallet)
(setq sql-password-wallet "~/.authinfo.gpg")

The value for sql-connection-alist is then as normal

(setq sql-connection-alist
  '((some-dbname (sql-product 'oracle)
                 (sql-port 1521)
                 (sql-server ...)
                 ...))

and the blocks in orgmode looks like this

SRC sql-mode :product oracle :dbconnection i3v1e-ro :results raw
SELECT to_char(sysdate, 'YYYY-MM-DD HH24:ii:ss') AS today,
       to_char(sysdate + 1, 'YYYY-MM-DD HH24:ii:ss') AS tomorrow
FROM dual;
SRC

Thoughts

Both of these feel closer to the intent of sql-mode in a way. I'll have to try using sql-connection-alist at some point.

Oskar Wickström: The Bombadil Terminal Experiment

Wed, 29 Apr 2026 22:00:00 +0000

Last week at Bug Bash 2026, I had a bunch of interesting discussions about testing non-web interfaces with Bombadil, our new property-based testing framework for user interfaces. One direction that I already wanted to explore is terminal user interfaces (TUIs), and the hallway discussions gave me a nudge to get going. I started hacking on the flight back home, and a few days later that embryo of a TUI fuzzer started to emerge.

The fuzzer in action, finding a bug in vitetris. (CW: flashing!)

It’s built on top of two key crates:

portable-pty, a pseudo-teletype in Rust that runs the program under test, and
libghostty-vt, a Rust wrapper around the Zig library, which interprets the output of the PTY and provides a virtual terminal API from which you can read cell contents, styles, scroll through the scrollback, etc.

With these two in place, I built a very basic fuzzer for TUIs: it runs the command you give it, polls its output, and writes interleaved random input sequences (printable ASCII characters and ANSI escape sequences). It also scrolls and resizes the terminal occasionally. Timing is a bit tricky, but it seems the current approach works fine: polling reads until the terminal is idle, capture state, then apply new inputs. Regarding speed, it depends a lot on the program being tested, but it looks capable of capturing at least 300 states per second.

I tried finding some basic TUI programs and terminal games to test. Much to my surprise, within the first few days I had found four seemingly real bugs in real software:

vitetris has a bug where if you enter just a number in the host name (e.g. 6) and try to connect to a remote game, the UI freezes.
btop has two different bugs, one recently fixed that I confirmed fixed with the latest version (1.4.6), and one that I just reported. Both were triggered by this fuzzer.
rlwrap got into a segfault which I haven’t yet been able to troubleshoot.

Pretty cool. Today, I merged this work to main in Bombadil. It’s not yet released, but if you’re curious you can try it already by downloading a bombadil-terminal binary from the CI artifacts. On macOS you’ll need to remove the quarantine bit to bypass GateKeeper.

Now, the work remains to make this a solid tool. Here are some future goals:

Integrate it with the specification framework in Bombadil, so that you can define custom properties and action generators. It’d be neat to provide an API akin to querySelector that could parse and traverse panels drawn with box-drawing characters. You probably also want to validate that those borders line up correctly.
Generate a lot more diverse input and terminal actions. For instance, generate sequences from the Kitty keyboard protocol.
Make the test runner’s user interface better. Perhaps a TUI?!
Make this part of the ordinary bombadil binary, I think. There could be subcommands for browser and terminal testing tools.
Run it in Antithesis to see what that fuzzer can find.

All right, short post today — I just wanted to share my excitement and early results.

A huge thanks to Uzair Aftab, maintainer of libghostty-rs, for helping me get libghostty-vt building under Nix!

Donnacha Oisín Kidney: Tries for Polynomials

Tue, 28 Apr 2026 00:00:00 +0000

Posted on April 28, 2026

Tags: Haskell

One of my favourite Haskell papers is McIlroyâ€™s wonderful â€œPower Series, Power Seriousâ€� (1999). The paper is about power series, which are a type of infinite sums that behave like (infinite) polynomials. For example, <semantics>cos<annotation encoding="application/x-tex">\cos</annotation></semantics> can be represented by the following power series:

<semantics>cos⁡(x)=1âˆ’x22!+x44!âˆ’x66!+x88!âˆ’x1010!+â‹¯<annotation encoding="application/x-tex">\cos(x) = 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \frac{x^6}{6!} + \frac{x^8}{8!} - \frac{x^{10}}{10!} + \cdots</annotation></semantics>

A power series is characterised fully by its coefficients, meaning that we can represent one as an infinite stream of rational numbers. In Haskell, we often use lazy lists to represent streams, so we can encode a power series with the following type:

type PowerSeries = [Rational]

In this encoding, we can write <semantics>cos<annotation encoding="application/x-tex">\cos</annotation></semantics> as the following:

cos :: PowerSeries
cos = zipWith (*) (cycle [1,0,-1,0]) (scanl (/) 1 [1..])

>>> cos
[1,0,-1/2,0,1/24,0,-1/720,...

We can also build <semantics>sin<annotation encoding="application/x-tex">\sin</annotation></semantics>:

sin = zipWith (*) (cycle [0,1,0,-1]) (scanl (/) 1 [1..])

While it can be difficult and unintuitive to work with infinite series like the ones above, happily we can define all of the normal numeric operations on power series as (lazy) list-manipulation programs:

instance Num PowerSeries where

  (x:xs) + (y:ys) = (x+y) : (xs + ys)

  (x:xs) * ys = map (x*) ys + (0 : xs * ys)

  negate = map negate

  fromInteger n = fromInteger n : repeat 0

(if you try and put this code into a Haskell interpreter youâ€™ll get all sorts of warnings; Iâ€™ll put the full code for this post below with all of the imports and pragmas you need to get it to work)

McIlroy (1999) goes through the various algorithms and numeric operations that can be implemented on this representation, but at this point I would like to diverge from the paper and turn our focus to finite polynomials. Like a power series, a finite polynomial can be represented by a list of coefficients:

type Polynomial = [Rational]

And, even though the underlying list is finite rather than infinite, the numeric operations work basically the same way as they do on power series. We just need to add clauses in each function to handle the empty list:

instance Num Polynomial where

  []     + ys     = ys
  xs     + []     = xs
  (x:xs) + (y:ys) = (x+y) : (xs + ys)

  []     * _  = []
  (x:xs) * ys = map (x*) ys + (0 : xs * ys)

  negate = map negate

  fromInteger n = [fromInteger n]

The only semantic trickiness with this representation is that itâ€™s important to quotient by trailing zeroes.

instance Eq Polynomial where
  [] == ys = all (0==) ys
  xs == [] = all (0==) xs
  (x:xs) == (y:ys) = (x == y) && (xs == ys)

Evaluation and Hornerâ€™s Rule

The definition of a power series above suggests that we should implement evaluation using exponentiation and indices:

eval :: Polynomial -> Rational -> Rational
eval p x = sum (zipWith (\a i -> a * x^i) p [0..])

And this does in fact give us the correct answer. Consider the polynomial <semantics>4+2x+5x2âˆ’x3<annotation encoding="application/x-tex">4 + 2x + 5x^2 - x^3</annotation></semantics>:

poly = [4,2,5,-1] -- 4 + 2x + 5xÂ² - xÂ³
eval poly x = eval [4,2,5,-1] x
            = sum (zipWith (\a i -> a * x ^ i) [4,2,5,-1] [0..])
            = 4*x^0 + 2*x^1 + 5*x^2 + (-1)*x^3
            = 4 + 2*x + 5*x^2 - x^3

However, this evaluation algorithm is unsatisfactory in one respect: it performs a lot of multiplication. In numeric programs, we generally want to minimise the number of multiplications performed, since multiplication is a relatively expensive operation (when compared to addition or subtraction). In the example above, it takes six multiplications to compute the result: one for <semantics>2x=2Ã—x<annotation encoding="application/x-tex">2x = 2 \times x</annotation></semantics>, two for <semantics>5x2=5Ã—xÃ—x<annotation encoding="application/x-tex">5x^2 = 5 \times x \times x</annotation></semantics>, and three for <semantics>âˆ’x3=âˆ’1Ã—xÃ—xÃ—x<annotation encoding="application/x-tex">-x^3 = -1 \times x \times x \times x</annotation></semantics>. In general, for a polynomial of degree <semantics>n<annotation encoding="application/x-tex">n</annotation></semantics>, the above implementation of eval will perform <semantics>ğ�’ª(n2)<annotation encoding="application/x-tex">\mathcal{O}(n^2)</annotation></semantics> multiplications.

There is, however, a trick that can bring the number of multiplications down to <semantics>ğ�’ª(n)<annotation encoding="application/x-tex">\mathcal{O}(n)</annotation></semantics>: Hornerâ€™s rule. The basic idea is to rewrite the expanded polynomial <semantics>4+2x+5x2âˆ’x3<annotation encoding="application/x-tex">4 + 2x + 5x^2 - x^3</annotation></semantics> into a factorised form: <semantics>4+x(2+x(5+x(âˆ’1)))<annotation encoding="application/x-tex">4 + x(2 + x(5 + x(-1)))</annotation></semantics>. If we evaluate this expression directly, we will only have to perform three multiplications (and we donâ€™t even have to perform any extra additions as compensation). While Hornerâ€™s rule is really quite a simple trick, the generalised pattern is surprisingly powerful (Gibbons 2011). Indeed, the representation I develop in this post is basically a data structure encoding of Hornerâ€™s rule.

Before getting there, however, letâ€™s return to our list-based polynomial, and look at using Hornerâ€™s rule to implement eval. Interestingly, the list-based representation has kind of already performed our factorisation for us. As a result, Hornerâ€™s rule evaluation is actually more natural to implement than the expanded version above.

eval :: Polynomial -> Rational -> Rational
eval xs x = foldr (\a p -> a + x * p) 0 xs

Multiple Variables

A cool trick with this representation is that if you want to support multiple variables you can smuggle them in through the coefficients. A polynomial in two variables is the same as a polynomial with coefficients drawn from another polynomial.

type TwoVar = [Polynomial]

To save us having to write a separate Num instance for TwoVar, we can instead generalise the Num instance on Polynomial above:

instance Num a => Num [a] where

The rest of the instance is the same. Now, we can write 5 ^ 2 :: Polynomial or 6 :: TwoVar and it will just work.

We also have to generalise the type of eval slightly:

eval :: Num a => [a] -> a -> a

but again, the implementation remains the same.

With this machinery, we can now write and evaluate polynomials in 2 variables:

eval2 :: TwoVar -> Rational -> Rational -> Rational
eval2 p x y = eval (eval p [x]) y

var :: Num a => [a]
var = [0,1]

x = var
y = [var]

poly = 2 * x ^ 2 - y ^ 3 + 4

>>> poly
[[4,0,0,-1],[0],[2]]

>>> eval2 poly 2 3
-15

We can even use some typeclass shenanigans to build a generalised evaluator that works with any fixed number of variables.

Implementation of an Evaluator for Polynomials in Arbitrary Variables

instance Num n => Num (e -> n) where
  fromInteger = const . fromInteger
  (f + g) x = f x + g x
  (f * g) x = f x * g x

  abs = (abs .)
  signum = (signum .)
  negate = (negate .)

class Num r => Poly p r | p -> r, r -> p where
  evalN :: p -> r

instance Poly Integer Integer where
  evalN = id

instance Poly p r => Poly [p] (Integer -> r) where
  evalN xs x = foldr (\a s -> evalN a + fromInteger x * s) 0 xs

>>> evalN poly 2 3
-15

z = [[var]]

>>> evalN (poly + z) 2 3 1
-14

Sums of Products

While the above representation is elegant, it is inefficient, and perhaps a little unintuitive. In most implementations I have seen, variables are represented simply with a type for names, rather than the kind of implicit de Bruijn indices used above. One natural representation uses a list of terms:

newtype Poly v c = Poly { terms :: [([v], c)] }

Here, a value of type Poly v c is a polynomial with coefficients drawn from c and variables from v. It is a list of monomials, where the outer list represents a sum, and each monomial represents a product of variables with a single coefficient.

data Var = X | Y | Z

poly :: Poly Var Integer
poly = Poly [([X,Y,Y],5),([Z],3),([Y,Z],2)]
-- 5xyÂ² + 3z + 2yz

Note that this representation requires some normalisation:

norm :: (Ord v, Num c, Eq c) => [([v],c)] -> [([v],c)]
norm = Map.toList . Map.fromListWith (+) . filter ((/=0).snd)

instance (Num c, Ord v, Eq c) => Eq (Poly v c) where
  (==) = (==) `on` norm . terms

And we have the following Num instance:

instance Num c => Num (Poly v c) where
  fromInteger n = Poly [([],fromInteger n)]
  Poly xs + Poly ys = Poly (xs ++ ys)
  xs * ys = Poly [ (xv ++ yv, xc * yc) | (xv,xc) <- terms xs, (yv,yc) <- terms ys ]
  negate = Poly . map (fmap negate) . terms

This representation perhaps maps more closely to the description of multivariate polynomials that many of us will have encountered in secondary school: itâ€™s straightforward to see how a polynomial like <semantics>2xy+y2âˆ’3<annotation encoding="application/x-tex">2xy + y^2 - 3</annotation></semantics> corresponds to the value Poly [([X,Y],2),([Y,Y],1),([],-3)]. The previous representation (TwoVar) would represent the same expression as the enigmatic [[-3,0,1],[0,2]].

However, there are some wrinkles to this type that are worth noting. First we can see that multiplication is not commutative (even after normalisation).

x = Poly [([X],1)]
y = Poly [([Y],1)]

x * y == Poly [([X,Y],1)]
y * x == Poly [([Y,X],1)]
x * y /= y * x

This is in contrast to TwoVar, where both <semantics>xy<annotation encoding="application/x-tex">xy</annotation></semantics> and <semantics>yx<annotation encoding="application/x-tex">yx</annotation></semantics> would be represented as [[0,0],[0,1]].

Conceptually, polynomials are a kind of free structure: they represent the normalised and quotiented syntax of an algebraic theory. The fact that Poly above doesnâ€™t have commutative multiplication just tells us that the underlying algebraic theory in question here is noncommutative rings, rather than commutative rings.

The second thing to note about this type is actually two related observations about inefficiency. Because I didnâ€™t implement normalisation on any of the numeric operations, we might expect the size of the underlying list of Poly to blow up:

poly = (1 + x) * (3 + 4) * (y + 2)

>>> terms poly
[([Y],3),([],6),([Y],4),([],8),([X,Y],3),([X],6),([X,Y],4),([X],8)]

>>> norm (terms poly)
[([],14),([X],14),([X,Y],7),([Y],7)]

And indeed it does, as you can see above. To counteract this, we can represent our polynomial as a mapping from monics (strings of variables) to coefficients:

newtype Poly v c = Poly { terms :: Map [v] c }

Num instance for Map-based polynomial

instance (Ord v, Num c) => Num (Poly v c) where
  fromInteger n = Poly (Map.singleton [] (fromInteger n))
  Poly xs + Poly ys = Poly (Map.unionWith (+) xs ys)
  xs * ys = Poly (Map.fromListWith (+) [ (xv ++ yv, xc * yc)
                                       | (xv,xc) <- Map.toList (terms xs)
                                       , (yv,yc) <- Map.toList (terms ys) ])
  negate = Poly . fmap negate . terms

While this new representation is an improvement over the un-normalised list, itâ€™s still not really â€œefficientâ€�. In particular, weâ€™re using lists as keys in the map; Haskellâ€™s Map is a binary search tree (though this caveat applies to most mapping structures), so search is always going to have to perform comparisons on the keys. When those keys are lists, that comparison takes time proportional to the length of each list. This is wasted effort that could be cached with a cleverer data structure.

This also brings the second observation about inefficiency into focus: we have lost our neat evaluation with Hornerâ€™s rule.

eval :: Num c => Poly v c -> (v -> c) -> c
eval (Poly mp) v = Map.foldrWithKey (\vs c s -> foldr ((*) . v) c vs + s) 0 mp

Weâ€™re back to performing <semantics>n<annotation encoding="application/x-tex">n</annotation></semantics> multiplications per term.

Both of these inefficiencies are actually the same pattern, and can be solved with a general form of Hornerâ€™s rule. We need to cache prefixes: the data structure that does that best is a trie.

A Trie

Hornerâ€™s rule saved us from performing redundant multiplications by factoring out common terms to the left. That was simple to implement in the single-variable case, but it can still apply for multiple variables. Take an expression like <semantics>(2+3xâˆ’5y)2<annotation encoding="application/x-tex">(2 + 3x - 5y) ^ 2</annotation></semantics>, and multiply it out to <semantics>4+12x+9x2âˆ’15xyâˆ’20yâˆ’15yx+25y2<annotation encoding="application/x-tex">4 + 12x + 9x^2 - 15xy - 20y - 15yx + 25y^2</annotation></semantics>. We can still factor this expression to remove common prefixes, like so:

The difference between this factorisation and the list-based polynomial we started with is that the tree representing the polynomial only had one child. Here, we have a child for each leading term. In terms of the data structure, where a list has a single tail in the cons case,

data List a = Nil
            | Cons a (List a)

The multivariate version of the same thing will be a tree

data Tree a = Nil
            | Cons a [Tree a]

Or, more specifically, a trie, where the subtree mapping is based on variables.

data Poly v c = c :<+ Map v (Poly v c)

A polynomial is a constant coefficient c plus the sum of variables drawn from v each multiplied by another polynomial. The polynomial above is represented with this type as the following:

4 :<+ {(X,12 :<+ {(X,9 :<+ {}),(Y,(-15) :<+ {})}),(Y,(-20) :<+ {(X,(-15) :<+ {}),(Y,25 :<+ {})})}

This trie type (with some improvements Iâ€™ll describe below) is the focus of this post; I think itâ€™s a cool data structure for representing polynomials.

The numeric functions on Tries

Letâ€™s first write evaluation:

eval :: Num c => (v -> c) -> Poly v c -> c
eval f (c :<+ vs) = c + Map.foldrWithKey (\v p s -> f v * eval f p + s) 0 vs

Notice that we have retrieved Hornerâ€™s rule: the evaluation of each term only performs a single multiplication; we donâ€™t have to repeat multiplications for terms that share prefixes any more.

(for those concerned with performance, it might be worth swapping out foldrWithKey with a strict variant. (also, this is somewhat unrelated but a bit of a pet peeve of mine: this is not a place where foldl' is the best option! foldl' is not a panacea!))

The numeric operations on this data structure can be implemented as follows:

deriving instance Functor (Poly v)

instance (Ord v, Num c, Eq c) => Num (Poly v c) where
  fromInteger n = fromInteger n :<+ Map.empty
  (n :<+ ns) + (m :<+ ms) = (n + m) :<+ Map.unionWith (+) ns ms
  (n :<+ ns) * ms = fmap (n*) ms + (0 :<+ fmap (*ms) ns)
  negate = fmap negate

Itâ€™s worth taking a moment to note how efficient these operations are (for a pointer-ridden high-level language like Haskell, that is). We donâ€™t have to compare any strings; we can use Data.Mapâ€™s efficient unionWith on single variables; and multiplication doesnâ€™t have to expand out any Cartesian product.

I will note that we do have to perform a little bit of normalisation for the derived Eq instance to be correct: we have to remove terms that multiply to zeros. Pruning dead branches like this is a pretty standard procedure on tries; in polynomial terms, that just means we have to get rid of entries in the map that evaluate to zero (so <semantics>x(2+y)+y(0)<annotation encoding="application/x-tex">x(2 + y) + y(0)</annotation></semantics> should be pruned to <semantics>x(2+y)<annotation encoding="application/x-tex">x(2 + y)</annotation></semantics>). This can be done without really changing the efficiency of the operations above, but it does make them slightly more verbose.

Normalising Num instance

For this version, we will rely on the extremely efficient custom merge operations in containers.

0 <+? ns | Map.null ns = Nothing
n <+? ns = Just (n :<+ ns)

instance (Ord v, Num c, Eq c) => Num (Poly v c) where
  fromInteger n = fromInteger n :<+ Map.empty

  a + b = fromMaybe 0 (add a b)
    where
      add (n :<+ ns) (m :<+ ms) =
        (n + m) <+?
          Map.merge
            Map.preserveMissing
            Map.preserveMissing
            (Map.zipWithMaybeMatched (const add))
            ns ms

  _ * (0 :<+ ms) | Map.null ms = 0 :<+ Map.empty
  (0 :<+ ns) * ms = 0 :<+ fmap (*ms) ns
  (n :<+ ns) * ms = fmap (n*) ms + (0 :<+ fmap (*ms) ns)


  negate = fmap negate
  abs = fmap abs
  signum (n :<+ _) = signum n :<+ Map.empty

Anyways, when we have all of the above instances, we can manipulate polynomials using the API you might expect, and the normalisation behaviour happens automatically.

data Var = X | Y deriving (Eq, Ord, Show)

var :: Num c => v -> Poly v c
var v = 0 :<+ Map.singleton v (1 :<+ Map.empty)

x,y :: Poly Var Integer
x = var X
y = var Y

poly = (2 + 3 * x - 5 * y) ^ 2
>>> poly
4 + Y*(-20 + Y*25 + X*(-15)) + X*(12 + Y*(-15) + X*9)

Lenses and Division

Lenses in Haskell are very cool, and personally I think one of the best demonstrations of their power is tries. A few years ago, when I was still on Twitter, I posted an implementation of a trie that fit in a tweet (gist link).

Tweet Trie

{-# LANGUAGE RankNTypes #-}

import Control.Comonad.Cofree
import Control.Lens hiding ((:<))
import qualified Data.Map as Map
import Data.Map (Map)
import Prelude hiding (lookup)
import Data.Maybe (isJust)
import Test.QuickCheck

type Trie a b = Cofree (Map a) (Maybe b)

string :: Ord a => [a] -> Lens' (Trie a b) (Maybe b)
string =
 foldr
   (\x r -> _unwrap . at x . anon (Nothing :< mempty)
                                  (\(v :< m) -> null v && null m) . r)
   _extract


insert :: Ord a => [a] -> b -> Trie a b -> Trie a b
insert xs x = string xs .~ Just x

lookup :: Ord a => [a] -> Trie a b -> Maybe b
lookup = view . string

delete :: Ord a => [a] -> Trie a b -> Trie a b
delete xs = string xs .~ Nothing

Lenses are what allowed this very terse implementation. The original purpose of lenses was to facilitate deep access in nested records and data structures: a trie is effectively a nested map, so itâ€™s no great surprise that lenses are a good fit.

It turns out that lenses are also useful for manipulating polynomial tries. At first, it might be difficult to see why: in the trie implementation above, a lens was used to build getters and setters for a mapping from strings to payloads. But what does that translate to in the context of a polynomial? What does it mean to â€œlook upâ€� a string of variables in some expression like <semantics>2x2+y<annotation encoding="application/x-tex">2x^2 + y</annotation></semantics>?

It turns out that lookups corresponds to division. For example, dividing the polynomial <semantics>2x2+y<annotation encoding="application/x-tex">2x^2 + y</annotation></semantics> by the monic <semantics>xx<annotation encoding="application/x-tex">xx</annotation></semantics> gives us a quotient <semantics>2<annotation encoding="application/x-tex">2</annotation></semantics> and remainder <semantics>y<annotation encoding="application/x-tex">y</annotation></semantics>.

>>> divMod (2 * x ^ 2 + y) [X,X]
(2, y)

This is already quite similar to a lens: before the van Laarhoven encoding, lenses were usually thought of as functions that took a data structure and returned a pair of the â€œfocusâ€� of the lens and the â€œrestâ€� of the structure. In polynomial terms, that â€œfocusâ€� is the quotient, and the â€œrestâ€� is the remainder.

But thatâ€™s a little vague. Letâ€™s construct the actual lenses here, in the van Laarhoven style:

constant :: Lens' (Poly v c) c
constant f (c :<+ vs) = fmap (:<+ vs) (f c)

vars :: Lens (Poly v c) (Poly v' c) (Map v (Poly v c)) (Map v' (Poly v' c))
vars f (c :<+ vs) = fmap (c :<+) (f vs)

isZero :: (Num c, Eq c) => Poly v c -> Bool
isZero (n :<+ ns) = (0 == n) && Map.null ns

factored :: (Ord v, Num c, Eq c) => [v] -> Lens' (Poly v c) (Poly v c)
factored = foldr (\v vs -> vars . at v . anon 0 isZero . vs) id

This last lens does indeed give us an interface that looks like division:

>>> view (factored [X,X]) (2*x^2 + y)
2

>>> set (factored [X,X]) 0 (2*x^2 + y)
Y

If we want to define an actual division function, we can define it in terms of factored, in a fun example of the kind of golfy code that lens enables.

divMod :: (Ord v, Num c, Eq c) => Poly v c -> [v] -> (Poly v c,Poly v c)
divMod p vs = factored vs (,0) p

>>> (2*x^2 + y) `divMod` [X,X]
(2,Y)

GrÃ¶bner Bases

While the interface above lets us do some basic computer algebra, to do any serious work with polynomials we will have to at some point compute GrÃ¶bner bases. A GrÃ¶bner basis isâ€¦ somewhat hard to define, actually. Iâ€™ll quote an explainer on the topic by Sturmfels (2005):

A GrÃ¶bner basis is a set of multivariate polynomials that has desirable algorithmic properties

Basically, in several algorithms over polynomials (division, Gaussian elimination, etc.) it becomes necessary at some point to compute this thing called a GrÃ¶bner Basis.

There is a lot of published literature on computing GrÃ¶bner bases in different settings. However, the trie polynomial I have built above is fundamentally noncommutative, and the literature on computing GrÃ¶bner bases for noncommutative rings is comparatively smaller. I have been following Xiuâ€™s thesis (2012) for this project. It outlines a noncommutative version of Buchbergerâ€™s algorithm, and a few optimisations that I was able to implement.

One slightly annoying aspect of these algorithms is that they tend to use monomials as a primitive. In other words, instead of working with the polynomial directly, the algorithms tend to describe operations with the assumption that your representation is basically a list of monomials. In particular, the algorithms will frequently extract the â€œleadingâ€� monomial, and it becomes important for performance that the polynomial representation can provide that leading monomial quickly. Unfortunately, extraction of the leading monomial is slightly awkward on the trie representation (or certainly less natural than the implementation on a listed representation); so we will need to do some work to implement it.

Monomial Orderings

The first important concept to implement for GrÃ¶bner bases is an admissible monomial ordering. This is a total order on strings of variables that is â€œadmissibleâ€�; meaning that it respects concatenation on both sides, and it also is a well-ordering, meaning that any strictly descending chain is finite.

These constraints rule out the usual lexicographic ordering on strings. Instead, weâ€™ll go with graded lexicographic. This means we first compare strings for length, and only in the case where theyâ€™re equal do we move to the normal lexicographic comparison.

grlex :: Ord a => [a] -> [a] -> Ordering
grlex xs ys
  | length xs < length ys = LT
  | length xs > length ys = GT
  | otherwise = compare xs ys

We can improve the efficiency of the above function somewhat by using one of my favourite monoids: the monoid instance on Ordering.

grlex :: Ord a => [a] -> [a] -> Ordering
grlex = go EQ
  where
    go !a []     []     = a
    go !a []     (_:_)  = LT
    go !a (_:_)  []     = GT
    go !a (x:xs) (y:ys) = go (a <> compare x y) xs ys

This version performs just one pass through each list, and does the correct comparison without additionally calculating the length. Itâ€™s also nonstrict: if one of the lists passed is infinite, this comparison will still terminate.

Another admissible order we could use is reverse grlex, which basically amounts to reversing the lists before the comparison. The trie structure means that weâ€™re basically forced to use grlex, but I will include an implementation of grevlex here because I think itâ€™s cute.

Implementations of grevlex

grevlex :: Ord a => [a] -> [a] -> Ordering
grevlex []     []     = EQ
grevlex (_:_)  []     = GT
grevlex []     (_:_)  = LT
grevlex (x:xs) (y:ys) = grevlex xs ys <> compare x y

-- This version is tail-recursive, but it also might unnecessarily compare
-- elements. However, that should be cheaper than building up the list of
-- comparisons.
grevlex :: Ord a => [a] -> [a] -> Ordering
grevlex = go EQ
  where
    go !a []     []     = a
    go !a (_:_)  []     = GT
    go !a []     (_:_)  = LT
    go !a (x:xs) (y:ys) = go (compare x y <> a) xs ys

Enumerating Monomials

The problem with all the admissible monomial orderings is that they need to see the entire monomial before they can decide whether itâ€™s ordered before or after another. This is at odds with the trie, which tends to prefer computations that can be described in terms of prefix/suffix decompositions.

To demonstrate the problem, letâ€™s take a look at an algorithm that enumerates the monomials of a polynomial in lexicographic order:

monos :: (Num c, Eq c) => Poly v c -> [([v],c)]
monos p = search [] p []
  where
    cons vs 0 ms = ms
    cons vs c ms = (reverse vs,c) : ms

    search sv (n :<+ ns) ms = cons sv n (Map.foldrWithKey (search . (:sv)) ms ns)

>>> monos ((2 + 3*x - 5*y) ^ 2)
[([],4),([X],12),([X,X],9),([X,Y],-15),([Y],-20),([Y,X],-15),([Y,Y],25)]

Notice that the function search emits the monomial (reverse sv, n) straight away (if n /= 0), when it encounters it: for a proper admissible monomial ordering, it would instead want to first emit monomials of higher degree; that is, those monomials in the map ns.

However, we canâ€™t just flip the order of consing in search: notice that even if we reversed the output, we still wouldnâ€™t get an admissible monomial ordering (the singleton list [Y] should be grouped with the other singleton lists). The problem is that monos is performing a depth-first search. What we need is breadth-first.

I happen to be a little obsessed with breadth-first search, so I probably spent too much time on this particular implementation, but I do always get excited when I see a breadth-first traversal pop up in the wild.

For this case, I started with the levels function.

levels :: (Num c, Eq c) => Poly v c -> [[([v],c)]]
levels p = search [] p []
  where
    cons _  0 ms = ms
    cons vs c ms = (reverse vs,c) : ms

    search sv (n :<+ ns) []     = cons sv n [] : Map.foldrWithKey (search . (:sv)) [] ns
    search sv (n :<+ ns) (q:qs) = cons sv n  q : Map.foldrWithKey (search . (:sv)) qs ns

>>> levels ((2 + 3*x - 5*y) ^ 2)
[[([],4)],[([X],12),([Y],-20)],[([X,X],9),([X,Y],-15),([Y,X],-15),([Y,Y],25)]]

I have written about levels before (see also Gibbons 2015; Jones and Gibbons 1993).

I think itâ€™s a good fit here because it lets us build the prefix string for each monomial in a natural way (that prefix string is the sv thatâ€™s passed to search).

However, one flaw of this function is that it produces a list of lists: one inner list for each degree of polynomial. The output that I actually want, however, is the concatenation of the whole thing.

In reality, this isnâ€™t actually a flaw: we can just call concat and move on. I had a feeling, though, that there was probably some annoying circular program that would let us avoid the second traversal to concatenate the inner lists. Inspired by Geraint Jonesâ€™ cyclic breadth-first traversal (1993), I finally arrived at the following solution:

data Knots a
  = Knot
  { tied :: !Bool
  , yank :: [a]
  , ends :: Knots a }

tighten :: Knots a -> Knots a
tighten ~(Knot t y e) = Knot False (if t then y else []) (tighten e)

monos :: (Eq c, Num c) => Poly v c -> [([v],c)]
monos p = y
  where
    Knot _ y e = tie [] p (tighten e)
    cons sv 0 ms = ms
    cons sv c ms = (reverse sv, c) : ms
    tie sv (n :<+ m) (Knot _ ms ps) = Knot True (cons sv n ms) (Map.foldrWithKey (tie . (:sv)) ps m)

>>> monos ((2 + 3 * x - 5 * y) ^ 2)
[([],4),([X],12),([Y],-20),([X,X],9),([X,Y],-15),([Y,X],-15),([Y,Y],25)]

While this does order the output according to grlex, itâ€™s ordered from smallest to largest, which is the reverse of what we want. And yes, while we could just reverse the output, I didnâ€™t write the circular abomination above to throw away the single-pass traversal at such a small hurdle. Any (list-based) algorithm written in a fold-like fashion can usually be reversed by swapping out right-folds for left.

pull :: Knots a -> [a]
pull (Knot True _ e) = pull e
pull (Knot False y _) = y

monosDesc :: (Eq c, Num c) => Poly v c -> [([v],c)]
monosDesc p = pull r
  where
    r = tie [] p (Knot False [] (tighten r))
    cons sv 0 ms = ms
    cons sv c ms = (reverse sv, c) : ms
    tie sv (n :<+ m) (Knot _ ms ps) = Knot True (cons sv n ms) (Map.foldlWithKey (\a v p -> tie (v:sv) p a) ps m)

Efficiently Popping the Leading Monomial

Unfortunately, as fun as monosDesc is, it doesnâ€™t really do what we need it to for most of the GrÃ¶bner basis algorithms. While it is pretty efficient if we want all of the monomials of a polynomial, usually we just want the first one. And sadly, while monosDesc is linear overall, itâ€™s not lazy in the right way, meaning that we have to pay that full linear cost even if we only inspect the first element of the list it produces.

The solution here will require us to use a new data structure in place of the Map that we have currently. To avoid traversing the whole tree to find the largest monomial, we need to cache the depth of each subterm so that we can just descend into the subterm which contains the monomial of the highest degree. But we donâ€™t want to just swap out our Map v (Poly v c) for a Map v (Word, Poly v c): that solution would require us to walk over every entry in the map to find the largest Word. While it would be an improvement in practical terms, it would still incur an <semantics>ğ�’ª(widthÃ—depth)<annotation encoding="application/x-tex">\mathcal{O}(\text{width} \times \text{depth})</annotation></semantics> cost to find the leading monomial.

Instead, we need the map itself to be able to efficiently provide the entry with the largest degree. We need our map to simultaneously act as a priority queue.

Luckily, the combination of these two structures has been researched before: Hinze (2001) wrote about â€œpriority search treesâ€�, a data structure that allows for <semantics>ğ�’ª(log⁡n)<annotation encoding="application/x-tex">\mathcal{O}(\log n)</annotation></semantics> lookup and insertion based on some ordered key, and separately allows for a <semantics>ğ�’ª(log⁡n)<annotation encoding="application/x-tex">\mathcal{O}(\log n)</annotation></semantics> popMin operation, based on some separate priority. The psqueues package provides a few implementations of this technique. The API isnâ€™t quite as extensive as, say, containers, so some functions will be slightly less efficient (we donâ€™t get a nice general merge function, for example), but we can basically drop in the OrdPSQ as a replacement for Map.

type SubTerms v c = OrdPSQ (Down v) (Down Word) (Poly v c)
data Poly v c = c :<+ SubTerms v c

Iâ€™m using the Down wrapper here because I want a max heap, rather than a min-heap. Iâ€™m using that wrapper on both the keys and priorities because OrdPSQ breaks priority ties according to the keys, and I also want greater keys returned first, to follow the grlex ordering.

The priority here is the depth of the tree. It tells us the length of the longest monomial contained:

depth :: Poly v c -> Word
depth (_ :<+ ns) = maybe 0 (\(_,Down p,_) -> succ p) (Map.findMin ns)

This operation is <semantics>ğ�’ª(1)<annotation encoding="application/x-tex">\mathcal{O}(1)</annotation></semantics>, since finding the minimum entry in OrdPSQ is <semantics>ğ�’ª(1)<annotation encoding="application/x-tex">\mathcal{O}(1)</annotation></semantics>.

Iâ€™ll also use the following isomorphism, for the lensy things:

entry :: (Num c, Eq c) => Iso' (Maybe (Down Word, Poly v c)) (Poly v c)
entry = iso (maybe (0 :<+ Map.empty) snd) (\p -> if isZero p then Nothing else Just (Down (depth p), p))

This lets us chain together lenses that index into an OrdPSQ.

factored :: (Ord v, Num c, Eq c) => [v] -> Lens' (Poly v c) (Poly v c)
factored = foldr (\v ls -> vars . at (Down v) . entry . ls) id

Finally, we can implement a function that pops the leading monomial from a polynomial, efficiently:

leading :: (Num c, Eq c, Ord v) => Poly v c -> Maybe (([v],c),Poly v c)
leading p | isZero p = Nothing
leading (n :<+ ns) = Just (retrie (Map.alterMin step ns))
  where
    retrie ((r,n'),ns') = (r, n' :<+ ns')

    step Nothing = ((([],n),0),Nothing)
    step (Just (Down v, _, p)) = (((v:vs,c),n), subTrie)
      where
        Just ((vs,c),p') = leading p
        subTrie | isZero p' = Nothing
                | otherwise = Just (Down v, Down (depth p'), p')

And it matches the earlier enumeration that we built:

prop_leadingMonos :: Poly Var Word -> Property
prop_leadingMonos p = monosDesc p === unfoldr leading p

Next Steps

I think this is an interesting data structure, and representation of polynomials. However, I am not very familiar with the computer algebra literature, so I canâ€™t yet tell how this kind of representation relates to the other systems out there. Furthermore, most of the algorithms I have read seem to work implicitly with â€œleading monomialsâ€� etc., leading to the following kind of implementation of division:

divModPrefM :: (Fractional c, Eq c, Ord v) => Poly v c -> ([v],c) -> (Poly v c, Poly v c)
divModPrefM p (vs, i) = factored vs ((, 0) . fmap (/i)) p

divModPref :: (Fractional c, Eq c, Ord v) => Poly v c -> Poly v c -> (Poly v c, Poly v c)
divModPref num divisor = case leading divisor of
  Nothing -> error "Divide by zero"
  Just (lt, rest) -> go 0 num
    where
      go !quot !rem = case divModPrefM rem lt of
        (0, _) -> (quot, rem)
        (q, rem') -> go (quot + q) (rem' - rest * q)

I feel that this doesnâ€™t make use of the benefits of the trie-based representation. I have implemented Buchbergerâ€™s algorithm (with most of the improvements from Xiu 2012), but I have yet to really research in depth what competitively fast systems do these days (Heisinger and Hofstadler 2025; Cohen and Knopper 2026; Levandovskyy, SchÃ¶nemann, and Zeid 2020). Iâ€™m also interested in seeing what kinds of applications there are for this stuff: I started this project with Weyl algebras in mind, but after looking into it a little more it seems clear that a trie is not a good fit for Weyl algebras.

I have looked a little bit at some other Haskell work on polynomials and similar things; Zucker (2018) implemented listed polynomials very similar to the ones I had at the start of this post, as did Manzyuk (2012) and Buteau (2013). Iâ€™ve seen some bigger Haskell packages that work with polynomials (Malaquias and Lopes 2007; Ishii 2018; Laurent 2024), though none seem to use a representation similar to the trie here. I also had a look at calculi (Barton 2024), but I think that that project mainly works with commutative rings (although itâ€™s pretty big project, so I wouldnâ€™t be surprised if there was some module I missed).

I would actually be interested to hear if anyone has any pointers to work that has a similar approach to polynomials, or on the kinds of things that people use these noncommutative polynomials for. I find most of the descriptions of these algorithms difficult to parse (since theyâ€™re usually written by and for mathematicians rather than computer scientists, and almost never for functional programmers), so I am sure Iâ€™m missing some major projects.

Gists

Listed Polynomial with arbitrary variables

Polynomial Trie

References

Barton, Dave. 2024. â€œCalculi.â€� https://github.com/DaveBarton/calculi.

Buteau, Samuel. 2013. â€œPolynomials - School of Haskell School of Haskell.â€� School of Haskell. https://www.schoolofhaskell.com/user/Sam567/computational-physics/beginner-s-tools/polynomials.

Cohen, Arjeh M., and Jan Willem Knopper. 2026. â€œGBNP.â€� GAP packages. https://github.com/gap-packages/gbnp.

Gibbons, Jeremy. 2011. â€œHornerâ€™s Rule.â€� Patterns in Functional Programming. https://patternsinfp.wordpress.com/2011/05/05/horners-rule/.

â€”â€”â€”. 2015. â€œBreadth-First Traversal.â€� Patterns in Functional Programming. https://patternsinfp.wordpress.com/2015/03/05/breadth-first-traversal/.

Heisinger, Maximilian, and Clemens Hofstadler. 2025. â€œF4ncgb: High Performance GrÃ¶bner Basis Computations in Free Algebras.â€� arXiv. doi:10.48550/arXiv.2505.19304. https://arxiv.org/abs/2505.19304.

Hinze, Ralf. 2001. â€œA simple implementation technique for priority search queues.â€� SIGPLAN Not. 36 (10) (October): 110â€“121. doi:10.1145/507669.507650.

Ishii, Hiromi. 2018. â€œA Purely Functional Computer Algebra System Embedded in Haskell.â€� In, 11088:288â€“303. doi:10.1007/978-3-319-99639-4_20. https://arxiv.org/abs/1807.01456.

Jones, Geraint, and Jeremy Gibbons. 1993. Linear-time breadth-first tree algorithms: An exercise in the arithmetic of folds and zips. Dept of Computer Science, University of Auckland. https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/linear.ps.gz.

Levandovskyy, Viktor, Hans SchÃ¶nemann, and Karim Abou Zeid. 2020. â€œLetterplace: A subsystem of singular for computations with free algebras via letterplace embedding.â€� In Proceedings of the 45th International Symposium on Symbolic and Algebraic Computation, 305â€“311. ISSAC â€™20. New York, NY, USA: Association for Computing Machinery. doi:10.1145/3373207.3404056.

Malaquias, JosÃ© Romildo, and Carlos Roberto Lopes. 2007. â€œImplementing a computer algebra system in Haskell.â€� Applied Mathematics and Computation 192 (1) (September): 120â€“134. doi:10.1016/j.amc.2007.02.126.

Manzyuk, Oleksandr. 2012. â€œGrÃ¶bner bases in Haskell: Part I.â€� Oleksandr Manzyukâ€™s Blog. https://web.archive.org/web/20221206080655/https://oleksandrmanzyuk.wordpress.com/2012/10/25/grobner-bases-in-haskell-part-i/.

McIlroy, M. Douglas. 1999. â€œPower Series, Power Serious.â€� J. Funct. Program. 9 (3) (May): 325â€“337. doi:10.1017/S0956796899003299.

Sturmfels, Bernd. 2005. â€œWhat is... A GrÃ¶bner Basis?â€� Notices of the AMS 52 (10) (November). https://www.ams.org/journals/notices/200510/what-is.pdf.

Xiu, Xingqiang. 2012. â€œNon-commutative GrÃ¶bner Bases and Applications.â€� PhD thesis, UniversitÃ¤t Passau. https://opus4.kobv.de/opus4-uni-passau/frontdoor/index/index/docId/170.

Zucker, Philip. 2018. â€œDivision of polynomials in haskell.â€� Hey There Buddo! https://www.philipzucker.com/division-of-polynomials-in-haskell/.

Planet Haskell

Well-Typed.Com: Whole project loading for Haskell IDE tooling

Multi component sessions

Whole project loading

In Haskell Language Server

In Haskell Debugger

How it works and further configuration

Conclusion

Gabriella Gonzalez: Dependent if expressions without dependent types

Haskell Interlude: 85: Brent Yorgey

Philip Wadler: The Gargantuan Lie That is Collapsing the World's Climate

Philip Wadler: There is No AI

Sandy Maguire: review2

No More Monads

Constructing Again, Again

Circling Back to Selectives

Chris Smith 2: How to (Almost) Trisect an Angle

What you can trisect

Idea #1: Trisect the chord instead

Idea #2: Trisect a semicircle instead

Bridge: The exact residual trick

Putting the pieces together

Mark Jason Dominus: The road to epsilon-zero: Shortlex order also orders sequences of numbers

Sandy Maguire: Code-Reviewing My First Monad Implementation

Mark Jason Dominus: The road to epsilon-zero: Productive programs and well-founded orders

Infinite lists

Printing strings in sorted order

Not every program is productive

Lexicographic order isn't well-founded

Shortlex order

Magnus Therning: Emacs salmagundi, 2026-08-13

Limiting enabled tree-sitter modes

Tree-sitter grammar for Cabal files

Hello editable xref, good bye wgrep

Footnotes:

Mark Jason Dominus: There are two kinds of theorems

Abhinav Sarkar: Fast Haskell Scripts on GitHub Actions

The Setup#

The Problem#

The Idea#

The Bundle#

Creating the Bundle#

Bundling glibc?#

Running the Bundle#

The GitHub Actions Workflow#

The Payoff#

The Conclusion#

Like, repost, or comment on:

Oskar Wickström: How Antithesis Found and Explained a Bombadil Race Condition

A Simple Reproduction with Causality Analysis

The Bug

In Conclusion

Mark Jason Dominus: The road to epsilon-zero: Coin-moving games with no coins

Philip Wadler: Just Work: The Gig Economy, Platform Capitalism and the Battle for Worker Rights

in Code: "Five-Point Haskell": Unconditional Election (via Parametricity)

Choice is a Prison

Conditional Election

The Guessing Game

The More you Surrender

It’s Only Natural

Add a Type Variable

Ranking Up

Ensuring structural preservation

Ensuring lexically-confined resources

Habits to Build

Embracing Unconditional Election

The Next Step

Special Thanks

Mark Jason Dominus: Seven books I keep close because I love them

Roget's Thesaurus (4th edition)

The Prose of Sir Thomas Browne

Boccaccio's Decameron

From Frege to Gödel, edited by van Heijenoort

Orbis Sensualium Pictis (English edition), Johannes Comenius

The Bible (New International Version, large print)

The Belles Heures of Duc de Berry

#8?

Other stuff

GHC Developer Blog: GHC 9.12.5-rc3 is now available

GHC 9.12.5-rc3 is now available

Hello editable `xref`, good bye `wgrep`

New feature: `Context`