Right now, if I want to find the methods used by BTreeMap you have to wade through a good amount of information until you can find how to just get the keys. I'm currently on mobile where the issue is more prominent.
I mean, that works, but it's a workaround and not a solution.
That said, yeah, I hear you. It can still be tough sometimes. At some point, I'd love to work with some sort of information design / UX person to totally re-do rustdoc's output. There's a surprising number of thorny problems there. But there's always so much to do...
I feel I am getting over the hump of learning rust now and coding in rust is becoming less frustrating for me.
However, one thing that slows me down is the lack of indices in the documentation. For instance, if I want to know the return type of a vector len() I go here:
https://doc.rust-lang.org/std/vec/struct.Vec.html
.. and then I have to search the web page for all instances of "len". It would be good if there was an index similar to Javadoc, Godoc or Doxygen.
There might be a good reason for not having the index, but as a beginner it is lost on me.
If you click the little [-] button, you'll get an index for that page.
If you use the search bar at the top, https://doc.rust-lang.org/std/vec/struct.Vec.html?search=vec... will let you go right to the method. (In this case, you have to know that it's slice::len though)
Does that help?
EDIT: UX is hard! Glad people are discovering this. It's the same symbol HN uses, incidentally...
A polite suggestion - maybe the link marked [-], that takes you to the index, could be labelled "index".
I would echo the suggestions to make that button much more visible. Or perhaps even have the top-level description expanded by default but method/trait descriptions hidden. I can't think of a case where you'd simultaneously want to see every method description.
Seems like there's some UX improvements that could happen there.
I understand memory management in C. I understand it modern C++ (destruction when going out of scope, smart pointers etc).
Basically, a description and discussion of borrow-checking for people who have already used system programming languages would be really helpful. I feel like the book is targeting people who have only used garbage collected languages.
Or is the memory management of rust so novel it can't be described in those terms? I find the concepts aren't very concrete to me.
I try generally to keep other languages out of Rust's docs for various reasons, but agree that these kinds of resources are useful; I wrote "Rust for Rubyists" after all!
I'm hoping that others will step in and fill this gap; the repo in my sibling is a great start.
Varints: https://crates.io/crates/varint
Bloom filters: https://crates.io/crates/bloom
Iron: https://github.com/iron/iron
All the accessories for Iron: authentication middleware, integration with OAuth2, cookie-signing, integration with templating systems, etc. Also, an omakase framework (like Django or Rails) that pulls together a bunch of useful libraries into one crate that you can just use (with good docs) and not have to wire everything up.
Websockets: https://github.com/cyderize/rust-websocket or https://github.com/housleyjk/ws-rs
Server-sent events. I don't see a good alternative for these yet.
ElasticSearch: https://github.com/benashford/rs-es or https://github.com/erickt/rust-elasticsearch or https://github.com/KodrAus/elasticsearch-rs
An easy documentation/website generator for small libraries, that pulls examples, tests, and README files out of GitHub, runs RustDoc, and generates a professional-looking website that provides all the info that you need to get started with a library, with a minimum of extra effort for the library author. Basically, automate the job of going through libraries built to scratch someone's personal itch and "productizing" them.
Any of these could be a good project for a beginner, since there's already a lot of existing code to learn from, a small well-defined task, and an existing maintainer who has an incentive to help. Basically, just take a library, try to use it in a small test program (Linus's Law: "Never try to make a big important program. Always start with a small trivial program, and work on improving it"), and if anything is difficult or doesn't work right, figure out how to make it less difficult for the next person who runs across it and submit a pull request with that. As an added bonus, you can learn a lot of domain knowledge or basic CS data structures through digging through this, and that transfers to programming outside of Rust.
Try solving the problems without looking at the solutions first: https://github.com/brianquinlan/learn-rust
Here is a rough rank of difficultly: https://github.com/brianquinlan/learn-rust#understandability