Given the influx of newcomers from the 0.7 release, I thought it'd be a good idea to summarize the condition of Rust, its libraries, and its documentation. bstrie said it best I think, "basically, any question of the form 'is there a reason for this stupid and terrible thing' is 'no, sorry, we're working on it' ".
External iterators are a main feature of the 0.7 release, and there is ongoing
work to remove all of the library features that use internal iterators. Most
of them are gone, and there are few uses of internal iterators. However, they
are clunky to use. The
for loop semantics are going to change from internal
iteration to external iteration, but they are still internal iteration right
now, which means the
advance adaptor is necessary for most uses of
iterators. Additionally, the
iter() helper function is necessary to actually
return an iterator. This will be obviated by an
Iterable trait that many
things will hopefully implement. Due to
5898, many methods are oddly
named or have an underscore appended (ie,
transform instead of
position_ instead of
IO has been a bit of a losing proposition since at least 0.2. The interface is
very primitive and inefficient. It requires using
@Trait objects (
@Writer). It's also very undocumented. But the situation isn't going to
improve much because all of that code is getting torn out when brson/the
interns finish their work on the new runtime. On the plus side, we'll have
shiny new IO when they're done! If you want to contribute, there's plenty of
work to be done in this area:
The compiler is still buggy and inefficient. Lots of things work, but lots of
things don't. There's still some resolve bugs (the one mentioned above, as
well as some others, and perpetually poor error messages), default methods
don't work, debuginfo is incomplete, the compiler has quadratic codegen when
match, so on and so forth. There's a lot of work to be done here but
it's not easy. I'm writing a series about the compiler that should help new
contributors get started and grok how it all fits together. The only thing
making Rust usable right now is LLVM's fantastic optimization. Our no-opt
builds run slower than our opt builds under Valgrind. Ponder that for a
rustpkg is still heavily in-progress and unfinished. It's usable, but not everything is implemented, and the documentation is incomplete. It's rather unintuitive to use right now, but it does work! Read the manual carefully if you want to use it.
Documentation is poor.
rustdoc is really bad, which doesn't help. I'm
working on a new rustdoc (I log my progress
here), but it won't be ready for some weeks. Lots
of things are undocumented or near impossible to find because of how bad
rustdoc is. The tutorials need lots of work, and a guided tour of the
libraries would be nice, as well as a "Rust By Example," showing how to
accomplish common goals. These aren't really hard to do, it's just that nobody
has done them yet.
There are few robust libraries or bindings to libraries, for anything, besides
what is in std/extra. There's the stuff servo uses (glfw, skia, sdl), and an
opengl binding somewhere, but beyond that, you're on your own. The
rust-bindgen tool can help with
wrapping a C library. There is no GUI library available yet, no real
networking. It's easy to wrap a C library, you just need to be careful with
unsafe blocks. Once again, these things aren't hard, they just haven't
been done yet.
Basically everything is heavily WIP, but it's constantly improving. We always need more contributors, ask in IRC if you're interested. Rust 0.7 is pre-alpha quality, IMO. It would be silly to use Rust for something important, but don't let that stop you from trying to do something ambitious. If you feel Rust is still too young to get involved, but you want to track its progress, I write This Week in Rust, which is an easy way to track our progress. 1.0 is tentatively planned for first-quarter 2014, last I heard, and I don't think that is out of reach. 1.0 corresponds to "maturity #2" at the absolute minimum (the maturiy levels are listed as milestones).
But don't be discouraged. It was far worse before! Rust is in a good position, it's just not quite all there yet. This post may seem pessimistic, but the progress Rust has made is astonishing. Here's to a wonderful 0.8!