Daily report (2026-11-12)

1. Summary

Today work has focused on three things; The ctest extension matters, the Lean evaluator, and tweaking my Neovim configuration. The former two have seen slow progress, and the latter became necessary.

The ctest extension matters have been concerned with continuing work on yesterday’s efforts to detect codata patterns in module trees. The high-level idea of the strategy remains the same as explained then.

The small Haskell program to reproduce a scoped version of the problem was finished fairly early on. I then went on to think on the actual codata detection. This essentially consists of a stateful right-fold over the tree.

The way they are structured, both in Haskell and in the actual Rust program, module trees are essentially ADT rose trees. This means a fold over each “layer” of the rose tree attempts each path in turn for each child module.

An example will do best in illustrating this. Suppose we have a crate root with a child module “bar”. Now suppose as well that module “bar” has a super-relative import of all items under the crate root, which includes itself.

After two resolution passes, codata will become apparent because “bar” will be nested twice within itself. The details of why that is the case I will not explain today. The algorithm for detecting this codata I will.

Starting from module “bar,” we go down the path of descendant modules, attempting to match its item ID with each of those. For each module that does not match, we add it to a stateful graph path.

Once we reach a matching module (i.e. a duplicate, nested occurrence of module “bar,”) we check if this is the first of the two required occurences for codata. If it is not, then we repeat anew in the current subtree with a separate path.

If it is, then we compare the two graph paths we’ve gathered thus far (the first one (resp. the second one) to the first duplicated occurrence (resp. the second duplicated occurrence.) If they match, we have found a codata pattern.

This I’ve yet to iron out some more, but so far it seems feasible for the failing test case.

Lean-wise, work went into, again, the parsing implementation of the multiway arithmetic evaluator. That has gone fairly well, but it’s not done yet. This time I’ve worked on lexing and parsing spanned but undelimited tokens.

I first started off by continuing work on parsing binary operations, which prompted me to work on parsing spanned tokens. I already worked on delimited tokens yesterday, but this time it was about full naturals and such stuff.

This also got me to make a distinction between token streams and atoms. The latter are essentially an in-between representation between the AST expression type and the raw strings resulting from lexical analysis.

I ended up not working anymore on this because some stuff I had not yet finished in my Neovim configuration was getting annoying. So I culminated the day with that — I have fixed a bunch of stuff concerned with some self-made plugins.

Chief among them was the cursor centering plugin, which I had gotten working in normal mode, but not quite so in insert mode. I reviewed the code after a few weeks, and noticed where the mistake was in.

2. Blockers

None.

3. Plan for the week

I expect to continue working on the ctest extension matters tomorrow. That, alongside Lean work, will likely have to be a bit delayed while I finish some more stuff from my Neovim configuration.