salsa VS participle

There are some excellent crates already in the Rust ecosystem (notably Salsa) for performing incremental computation, although they generally have different goals to Depends.

The content of that "Core Concepts" page sounds a lot like https://github.com/salsa-rs/salsa

I know of salsa, but I don't know if it can persist changes to disk (and my guess from looking at this issue is that it can't).

- the practical approach to this is to split workload into work units (aka tasks/queries/etc.) and then force information flow through centralized "request"/"query" APIs that automatically track dependencies - see https://github.com/salsa-rs/salsa for more information

This, and as pointed Salsa.

These guys might be of interest for you, they think a lot about incremental parsers. https://github.com/salsa-rs/salsa

salsa-rs authored by niko matsakis and other top rust devs

Some optimizations are not easy with Go. For example caching like in Rust Analyser Salsa Framework

How would this differ from salsa (https://github.com/salsa-rs/salsa) and the query-driven approach used by rustc?

I know of tools like Kaitai that do essentially what I want, just curious about my options. I guess something like https://github.com/alecthomas/participle could work to parse the format, then I'd have to generate code based on the parsed data or something

This one was recommended in an older thread and looks like it's still actively developed: https://github.com/alecthomas/participle

I like participle: https://github.com/alecthomas/participle. It's pretty easy to get something working if it fits your use case.

Like the other commenters said, it's probably best to just split the string and go through it manually. If you need a real parser, check out: https://github.com/alecthomas/participle

I used https://github.com/alecthomas/participle to implement a custom DSL for some projects. I think there's also an SQL example in the repository. After the parsing is solved it's 'only' about doing something useful with the query but at least you've full control of all aspects, which features you'd like to support and so on.

I made a domain specific language using https://github.com/alecthomas/participle what I found interesting is the grammar defined in structure annotations. After the parser runs, you get a fully instantiated structure based upon the input. I then invoke structure methods to do the work described in the DSL.

Maybe instead of regex you could look into other options.

Shameless plug, but have you compared your Rust parser to https://github.com/alecthomas/participle?