And https://play.rust-lang.org/ can be used to test snippets of Rust code w/o having to install compiler. The best feature is you can make a link to your code for others to review.
I found this to be okay as a relatively speedy intro. It's quite disorganised though - some concepts and terms appear to be assumed but then introduced properly later on. I was wondering if this was intentional or not (maybe you are supposed to be patient?).
Rust by Example was actually not originally a Rust team project. It was an independent work that was handed over to the Rust team for maintenance by the original author.
As I understand, it received basic polishing and updates to make sure it was correct, but hasn't been edited much beyond that.
This history is accurate. RBE is pretty low on my priority list; finishing up the book and the standard library docs are much more important right now. I to try to keep up on PRs.
Not sure of the original intent, but when I started using Rust I used Rust By Example for finding snippets of things like file io where I get the gist but want to quickly see the pattern or involved parts of the stdlib.
The Rust docs are great, but having a starting point can be super welcoming so you aren't poking around blindly at different types that might be relevant.
Yeah it's more of a well-connected graph than a tree. Most of the examples that contain a concept that hasn't been covered include a link to where it is covered, and generally completely understanding the details in the example may help improve your understanding of the concept being introduced but isn't necessary to get a basic grasp.
That signifies a macro. It's meant to visually distinguish macros from ordinary function calls because macros may have arbitrary semantics (they can expand into any code at all). The stdlib defines `println` as a macro because it allows for a neat compile-time parsing of format strings.
Sounds like what Rust needs is compile macros [1]. That way, printf can still be a function, but it would be optimized at compile time if the formatting string is constant.
Compile macros wouldn't be sufficient for Rust's println! because the type signature (even the number of arguments) depends on the format string. The format string has to be constant and has to be interpreted at compile time so that the variables being printed can be type-checked.
