chalk VS polonius

The Rust compiler uses a Prolog-like query language internally for type checking generic requirements and traits: https://github.com/rust-lang/chalk

rust-analyzer already uses chalk (https://github.com/rust-lang/chalk) which should replace the current trait resolver.

Well it's quite easy to come to that conclusion: The code compiles with rustc, which is currently the reference implementation. If rust-analyzer does not match rustc's behavior it's an issue in their implementation. That written it's not that easy to fix as it's related to how rust-analyzer resolves types/traits. rust-analyzer uses chalk for this, which is known to be incomplete/diverging from the RFC'ed behavior. Now one could argue that we can simplify diesel to the point where it works will with rust-analyzer/chalk, but that would result in basically removing core diesel features that exist way longer than rust-analyzer.

> Not all of those things work well in the real world. E.g. logic programming (prolog) is cool but ultimately never really caught on.

It does have its niches though. For example, there is a trait solver for Rust called Chalk that uses a Prolog-inspired language because trait bounds basically define a logic:

https://github.com/rust-lang/chalk

Maybe something in the prolog/datalog direction could be useful? Notably Rust has Chalk to help with trait resolution ("Chalk is a library that implements the Rust trait system, based on Prolog-ish logic rules.")

There has been work to implement part of the Rust typing logic in the Chalk Engine which uses a prolog-ish syntax to describe its rules.

That's something Chalk is trying to tackle.

We probably will see all of them at some point -- polonius is a current effort to make the borrow checker accept more valid programs, in a way that also simplifies the logic and is probably a bit faster than the current NLL system, chalk is an attempt to do a similar thing for the trait system, and cranelift is a project that seeks to replace the LLVM codegen backend. But obviously, these are very large and complex projects that are gonna take some time.

Do Rust developers realize that? Oh, yes, absolutely, that's why we have this:

For me an attempt to write where HashMap: FromIterator and then use new and insert was totally bizzare because currently rustc is pretty primitive and doesn't do super-complex machinery needed to do what you want. Chalk may fix that one day, but it's nowhere near to being ready for inclusion into rustc thus I wouldn't even attempt to do what you tried to do… but that's not something you are supposed to know before reading this book!

Correctness prover which uses lifetimes (Polonius).

And, well, polonius (Rust borrow checker magic) I believe is built on datalog-ish concepts: https://github.com/rust-lang/polonius

There is also polonius (https://github.com/rust-lang/polonius) which should replace the borrow checker but does not receive a lot of development resources.

This is eventually going to be a feature-complete compiler, targeting a specific rustc version. I believe the plan is to use polonius [1], presumably as an "optional" feature so they can build a stage 1 without it, use that to build polonius, then build the final compiler with it included.

[1] https://github.com/rust-lang/polonius

E.g. there you may just stop using current borrow-checker and switch to Polonius.

The borrow checker is too dumb (https://github.com/rust-lang/polonius) fixes a lot of this.

It looks like an official borrow checker implementation called Polonius uses it as a dependency, so it makes sense: https://github.com/rust-lang/polonius/blob/981785c101b68ff54...

If you click around a little, you end up on a blog post with this tidbit:

> This project got put together rather suddenly, in response to some work the Rust folks are doing[1] on their new and improved borrow checker.

I don't think I could tell you more than "Frank wrote it to help rust folks who were previously doing work with differential-dataflow directly."

1. https://github.com/rust-lang/polonius/pull/36#issuecomment-3...

Good news is that there's also works going on to relax the restrictions, like polonius. But it seems that it still have a long way to go before it can land in stable Rust...

GCC-rs isn't intended for bootstrapping, it is intended to be an actual fully featured Rust compiler in the future, mrustc is a Rust compiler intended for bootstrapping though. GCC-rs is still very early targeting an older version of the reference compiler without things like a borrow checker, but that's not going to be the case forever. The GCC-rs folks have expressed interest in re-using the borrow checker library used by the reference compiler called polonius enabling them to relatively easily add borrow checking.