So fairly contrived example but not totally unrealistic. We're building an engine that evaluates many "rules" against the same very complex data structures, each rule is executed in it's own Parse / Compile phase and the rules can contain many logic gates basically like "generally speaking this data structure should have these values, except under these circumstances then we expect an entirely different value."

And when I say many, it could potentially be in the hundreds or thousands of rules.

In that example we do want to generally assert that values should be a specific value, but would also like the ability (in a different execution of a rule) assert that a specific value is a different one. We would want for our compilation step that compiles all the rules to be able to detect that these rules (which again are run as separate run contexts) conflict as they both touch providers.*.val and error for the user before submitting the rule, as a build time step, and avoid a situation where the rules are processed and we get explicitly contradictory responses.

Rectifying the issue is a separate issue we're still figuring out, but it'd probably turn into the globally scoped rule providing a not statement for the exceptional field. But the important thing for now is a way where we can detect these collisions. So our thoughts were walking OpCodes or the AST Tree and producing trees where we can quickly find rules that collide.

I unfortunately don't have any code to show for it as we're still in the implementation / investigation phase.

I'm actually working on something like this. Given N inputs, and M rules, instead of executing N*M programs, run "indexing" on M programs and run N*log(M) programs.

Let me know if you would be interested in something like this.