Closed by #1.

Completely changes the IR structure to reflect MLIR design choices. Ultimately, after carefully reading the MLIR documentation, I'm convinced that the MLIR design is a good optimum for extensibility -- clearly well thought out and designed, and supports the interfaces which I'd like to use to interact with extensible lattice interpreters.

• [X] IR re-implementation.
• [X] Test examples for a builtin dialect.
• [X] Operation traits.
• [x] Pass manager.

This change has introduced many advanced things into the codebase. It's likely less clear to someone observing how things actually work here, because I had to introduce concepts like trait objects, casting, and dynamic dispatch from Rust into the implementation to support the ability for my IR containers (e.g. Operation) to hold containers with intrinsics that are user-defined. The common solution in Rust for this is to use trait objects -- which is great and works (!), but trait objects prevents you from customizing behavior (e.g. by using Rust traits) on the thing that you just turned into Box<dyn SatisfiesTrait> (e.g. that you just introduced dynamic dispatch for). This thus requires designing an entirely new mechanism for enforcing traits (again, just like MLIR traits on these intrinsic-agnostic containers. The mechanism which I've implemented here relies on casting of trait objects, which is advanced usage of Rust's type system (specifically, std::Any and downcasting).

• [X] Implement operation trait - like mechanism.
• [X] Test examples.
• [x] Ruminate on this interface by writing a pass which uses it.

ariadne provides beautiful, contextual error messages (and so does things like codespan-reporting) -- I'd like to understand the right way to expose these error messages as part of a diagnostic infrastructure.

Mostly, ariadne has been used when you have a parser combinator, and the original String -- so you know the spans of objects after parsing. In the IR framework here, we actually have the IR first -- so this may require a novel Formatter implementation (e.g. a struct implement fmt::Write) which somehow tracks the spans for IR objects when being formatted into a string.

Re -- it's also not clear what parts of the infra should support these pretty error messages. Passes would be a good starting place to work on.

Discussion tracking: https://github.com/egraphs-good/egg/discussions/145

curious about this. Depends on scope of project, etc — but would certainly be interesting to look at