chumsky VS pest

I decided to look; just found these:

chumsky (parser combinator): https://crates.io/crates/chumsky

LALRPOP (LL):

I attempted to use this but was disheartened but the fact that it doesn't statically type node names. Tree Sitter doesn't either but it has much more of an excuse given that it targets C.

https://github.com/lezer-parser/lezer/issues/8

The dev seems mildly hostile to outside involvement too, so I moved on. These days I use Chumsky which is Rust rather than Typescript, but also way more awesome, if you can deal with the often incomprehensible compilation errors at least!

https://github.com/zesterer/chumsky

there’s also chumsky: https://github.com/zesterer/chumsky

We are using technique called parser combinator. And we are using a library chumsky to write parser combinators.

rust-langdev has a lot of libraries for building compilers in Rust. Perhaps you could use these to make your implementation easier, and revisit it later if you want to build things from scratch. I'd suggest logos for lexing, LALRPOP / chumsky for parsing, and rust-gc for garbage collection.

The examples that come with chumsky and the chumsky tutorial and guide all define their parsers using closures.

Parser: https://crates.io/crates/chumsky

chumsky's zero-copy rewrite has reached its first alpha release, and I have migrated my pep-508 parser to it, as suggested in my last announcement.

On my side, nom is still advancing well and a new major version is in preparation, with some interesting work a new GAT based design inspired from the awesome work on chumsky, that promises to bring great performance with complex error types. 2023 will be fun for parser libraries!

I have been on the lookout for something that code help me with Jinja and it seems like a plausible candidate. Extra bonus points if I could actually embed the Python in the same grammar but at this point even having the code blocks segregated from the literal parts is a good start

https://pest.rs/?g=N4Ig5gTghgtjURALhAMwJYBsCmACAvLsLgMoDyAkr...

I'll throw in a plug for https://pest.rs/ a PEG-based parser-generator library in Rust. Delightful to work with and removes so much of the boilerplate involved in a parser.

Would definitely be interesting, but from a cursory look at the repository, it doesn't look like squeezing the last percentage points of performance has been a priority yet.

Things that stand out:

- The `awk` implementation uses the Pest parser generator (https://pest.rs/), which is known to not generate the fastest possible parsers, but is great for getting up and running.

- They are using the `clap` crate for argument parsing, which is also known to not be the fastest, but again is very user friendly (for example, it does Unicode linebreaks in the output of `--help`). It's marginal, but for a tiny utility being invoked many times from a shell script, this can add up.

It's very probably "fast enough", and it makes sense to prioritize like this at this point, but people shouldn't use this expecting a performance improvement right now.

Nice work. Out of curiosity, did you consider using pest (https://pest.rs/) to help build your parser? Or is it too much for what you are doing?

And some related parser tools: - https://github.com/kevinmehall/rust-peg - https://github.com/pest-parser/pest - https://github.com/lalrpop/lalrpop

I had recently completed the first year of my Computer Science class at school and will begin my second year soon. My schools' class forces the use of Java programming language, and I absolutely hated it. So, over the course of a little less than a month, I wrote my own programming language, in Rust (objectively best programming language), using pest, to be as similar to Rust as possible, but compiling to Java.

I second pest.rs. Using it is fairly intuitive and there's also a live playground on their website which is great for quickly developing and testing your AST (abstract syntax tree) parser for whatever language you're implementing.