Today work has focused on two things; The ctest extension matters and the Lean book. The former has finally reached the point where all refactors after the path aggregate synchronization logic started being implemented are finished.
ctest-wise, things have been great. I reviewed once again yesterday’s work but couldn’t find any flaws. With that, I actually finished up the refactors for both the module path aggregate matters, and the path aggregate proper.
This meant I could now go back to matters purely concerned with keeping the path aggregate of any given item synchronized with that of all of its occurrences in the crate’s module tree.
This went quite well, though I did have to spend a fair amount of time reviewing the notes I took last week on this. I had to unwind my mental stack enough that it actually felt like it wasn’t me the one who had thought about this.
Once I picked up where I left off, I finished the first and most notable part of path aggregate synchronization. As mentioned last week, the one point where we know we can look up items with new paths is at merge time.
This I exploit to “update” (in a pure way) the module tree by searching for all occurrences of an item, and ensuring their path aggregates are in sync. This needed some special casing for modules, and that was a part of this week’s work.
The more specific plan for doing this goes through iterating through all items about to be merged, and calling a function that handles searching each item throughout the entire module tree.
This function is the one doing the heavy-lifting, and the one I finished today. Unlike last week, I do not pass a closure that synchronizes the path aggregate synchronization itself, because that’s too heavy a contract for callers.
Instead, I simply expect the path aggregate of the item I am looking up the occurrences of, and then “just” replace it with that of the items in the traversal with at least one matching path in their aggregate.
Lean work today doesn’t have anything specific to highlight. The book I’m working through had me reading some more about type classes, and some additional niceties Lean allows compared with, say, Haskell or Idris.
None.
I expect to have potentially finished an initial revision of the integration of the path sync logic into the main resolution algorithm by early next week. Then it’s going to be debugging and thinking about the next resolution algorithm.
This weekend I expect to perform the usual maintenance on the intercepting proxy server, followed by working through some more of the Hasochism paper from last weekend and Lean work.