Today work has focused on two things; Working on the ctest extension matters and continuing the Lean book. I have finished and started debugging the implementation for the path aggregate synchronization driver.
Last week, the path aggregate synchronization logic was finalized for a single given item. That was the biggest thing in what remained of the path aggregate refactor. This time I’ve implemented the driver to do that over a set of items.
The driver logic was fairly straightforward, but I’ve had moderate success in getting the synchronization to work as I expect it to. I found out a couple of bugs as I was perusing the code, and at first thought I had found a fix.
While running and rerunning the one test for which resolution does work, I realized that the module getting items imported to did not itself have the items in its subtree containing the latest path aggregate updates.
That lead to both a refactor and an attempt at fixing the merging procedure, but that seemingly only served for resolution to now stop working. That is still being investigated, but everything is pure so it’s an issue in my logic.
In terms of Lean work, I have finished working on the chapter that had taken me all of last week, and have since moved on to the next one. I also read up some on the choices you have for extending the Lean parser.
Apparently, Lean features a slightly less conveninent but very similar system to that of Racket. There’s facilities from going from custom operators declared as one-liners, to macros, to elaborators and to fully-fledged syntax extensions.
The most surprising part was to find that, if you really want to, you can even extend lexical analysis with tokenization procedures of your own. Coming from procedural macros in Rust, this was quite nice to hear.
Much like Racket, it all eventually has to converge to expressions in the core type theory that Lean (and I think the Lean kernel, more concretely) processes. Though I anticipate the Lean elaboration IR to be a bit harder to grasp.
None.
I expect to spend tomorrow debugging the issue I found while testing the path aggregate sync changes. Thus far, it seems fairly mysterious because the patch I implemented shouldn’t have had the effects it ended up having.
Lean-wise, I will continue working my way through the book. I looked into the syntax extensions to the language because I was interested in seeing whether I can get some of APL’s convenient array features elegantly encoded in Lean.