crate2nix VS proc-macro-workshop

I'll use nixpkgs' buildRustPackage. There's a few other tools, my favorite being crate2nix, but we'll leave that to a future tutorial.

If you want to iterate with nix instead of cargo, crate2nix and cargo2nix provides more caching and more fine control over your dependencies. I haven't used these two so you would have to decide for yourself. You may also want to try out nocargo for something more experimental.

I'm yet to try it out, but from the blog post, the README and the source it appears that Crane builds all dependencies in one derivation (separately from the main crate). This means that if a dependency gets added, removed or changed, all dependencies of a crate will be rebuilt. This is in contrast with https://github.com/kolloch/crate2nix, which does build every dependency in a separate package, thus you don't need to rebuild other dependencies if you only change a small part of the tree.

Yes, you will have to package it if it's not already in nixpkgs.

The good news is once you learn how, it's basically trivial with crate2nix[0], which can autogenerate nix derivations from rust crates

[0] https://github.com/kolloch/crate2nix

From my quick reading of cargo2nix's webpage yes. https://github.com/kolloch/crate2nix has a workspaces section.

As for your two applications, they're both written in Rust, and I like https://github.com/kolloch/crate2nix as a way to package Rust crates with Nix. BTW, wezterm is already in nixpkgs!

I like the way crate2nix works. I have made a flake template for it here. Sometimes it requires a couple of overrides to fix some misbehaving crates (see https://github.com/balsoft/simple-osd-daemons/blob/master/flake.nix#L29 for an example of such overrides), but otherwise it's fantastic. It doesn't require any hash nonsense, it downloads and builds all the crates separately (unlike naersk or other solutions) so you get all the benefits of Nix (reproducibility and proper caching).

Crate2nix might help: https://github.com/kolloch/crate2nix

Tangentially, the proc macro workshop walks through building a derive macro implementing a builder pattern. From experience, I can tell I couldn't ever write proc macros just by reading the manual, going through it is really helpful https://github.com/dtolnay/proc-macro-workshop/blob/master/README.md

I am working on the proc macro workshop and am a little stuck on the builder portion of the workshop. Step 08-unrecognized-attributes wants you to handle the car where the field modifier has a misspelled portion (eac instead of each)

I would very much second the suggestion to do David Tolnay’s Proc Macro Workshop if you want to start understanding how to write them. I’d been writing Rust for years but always kind of avoided proc macros.

When I had a need for them, I went through only the first section of the workshop and everything clicked. You can just do the derive macro section and all the strange and scary-looking macro syntax will make sense. I realized that there is only a bit of extra syntax but it’s used very often so it can seem a little overwhelming when reading macro code.

https://github.com/dtolnay/proc-macro-workshop

Another good one imo is the proc-macro-workshop.

Don't be afraid of proc macros and derive macros, they rule. Study the basic examples. Crates like darling and resources like David Tolnay's workshop will help. Write derives for your simpler traits and impress your colleagues.

Regarding 4, I think that macros are an interesting intermediate/advanced topic. I personally loved the material from https://github.com/dtolnay/proc-macro-workshop

It took me a while to get anything done. My mistake : I came accross the procedural macros workshop several times, and every time I dismissed it, thinking - meh I'll just hack together exactly what I need and move on. Then finally I figured there is no way around it. The builder exercise sounds boring but it covers the topic pretty well. And then I went on to the debug one and from there was able to build the proc macro I wanted.

Hey! While researching, I found this: https://github.com/dtolnay/proc-macro-workshop

Rust Latam: procedural macros workshop - David Tolnay