polonius

General programming [0], static analysis [1], RDF triple stores [2], authorization systems [3], incremental computation [4] [5], graph DBs [6]. But it is kind of hard to define Datalog exactly, since it is an entire family of technologies based on logic, each extending a clean mathematical model differently. [0] https://github.com/flix/flix [1] https://github.com/rust-lang/polonius [2] RDFox [3] https://github.com/eclipse-biscuit/biscuit [4] https://github.com/vmware-archive/differential-datalog [5] https://github.com/brurucy/pydbsp [6] https://github.com/cozodb/cozo

> It would be interesting if someone purpose-built a relation and rules database for compilers While not quite in rustc proper, along these lines: https://github.com/rust-lang/chalk + https://github.com/rust-lang/polonius

There isn't a formal definition of how the borrow checking algorithm works, but if anyone is interested, [0] is a fairly detailed if not mathematically rigorous description of how the current non-lexical lifetime algorithm works. The upcoming Polonius borrow checking algorithm was prototyped using Datalog, which is a logical programming language. So the source code of the prototype [1] effectively is a formal definition. However, I don't think that the version which is in the compiler now exactly matches this early prototype. EDIT: to be clear, there is a polonius implementation in the rust compiler, but you need to use '-Zpolonius=next' flag on a nightly rust compiler to access it. [0]: https://rust-lang.github.io/rfcs/2094-nll.html [1]: https://github.com/rust-lang/polonius/tree/master

> And until then someone might create a more ergonomic evolution of Rust. I wouldn't discount Rust's ability to create a more ergonomic evolution of Rust, because they already have. A few times. See: Polonius, https://github.com/rust-lang/polonius, and NLL, https://rust-lang.github.io/rfcs/2094-nll.html

Unfortunately I'm not super-familiar with developments around Polonius, so chances are what I can point you towards are the same things you found when searching. The most relevant bits appear to be the Polonius book [0] linked from the repo [1], but I don't know how up to date the book is or if there are more up-to-date resources. The RFC book [2] doesn't seem to have anything obviously about Polonius either. [0]: https://rust-lang.github.io/polonius/ [1]: https://github.com/rust-lang/polonius [2]: https://rust-lang.github.io/rfcs/

Alas, poor Yorick; I knew him well, Ferris. (Slightly more seriously, the project to replace the borrow checker was called Polonius[1], so it wouldn't be the first Hamlet reference in Rust land.) [1] https://github.com/rust-lang/polonius

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

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...

As I understand it, Polonius is still intended to be the next version of the borrow checker. The repostory is here: https://github.com/rust-lang/polonius There doesn't seem to have been any meaningful development for well over a year. There is some very recent discussion on Zulip which makes it look like there are at least two or three people interested in actively working on it. https://rust-lang.zulipchat.com/#narrow/stream/186049-t-comp...

Sometimes, what you're doing is unsound and so it must be forbidden even if you can't intuitively see why yet. Rust's diagnostics often show you why. However, sometimes (and for an experienced Rust developer this might start to happen more often than "Oh, actually that was dumb" type situations) the problem is that the Borrow Checker doesn't understand why it's fine. The diagnostic points you at something, and you say "Er, yeah, what's the problem?" and, sometimes, there wasn't really a problem. Non-lexical lifetimes were a big improvement in Rust, improving the borrow checking analysis so that more cases which are correct were allowed by the checker. Polonius is one thing intended to further improve upon this: https://github.com/rust-lang/polonius

There's also a Datalog implementation at https://github.com/rust-lang/datafrog . The Polonius reimplementation of the Rust borrowchecker uses Datafrog: https://github.com/rust-lang/polonius/

In the Rust ecosystem, I believe the next-generation IDE support is already beginning to incorporate some ideas like this, although I believe it uses Prolog rather than Datalog (I'd be interested to learn more about how they differ). The logic library is called Chalk ( https://github.com/rust-lang/chalk ), and it's designed to be a full trait resolution engine for Rust (trait resolution being a necessary step to e.g. autocomplete methods on types); rust-analyzer has been using it for quite a while now, and it's slowly being incorporated into rustc itself. Not as impressive as basing the entire IDE on queries, of course! The Rust project is also using the differential-datalog library mentioned in the OP to underlie their third-generation borrow checker: https://github.com/rust-lang/polonius

It's called "polonius": https://github.com/rust-lang/polonius There are some posts on Niko Matsakis' blog, starting with this one: https://smallcultfollowing.com/babysteps/blog/2018/04/27/an-... More recently a really good talk, with slides here: https://nikomatsakis.github.io/rust-belt-rust-2019/