Rust 0.6 RC is out
mail.mozilla.org
mail.mozilla.org
use task::spawn;
Edit: OK, need to add "core::" in front, thanks dbaupp. There's another little Rust 0.5 program I'm trying to unbreak here - suggestions appreciated: https://gist.github.com/graue/5282602
use core::task::spawn;In general, well done guys.
Personally, I don't think there's enough code 'in the wild' to justify this at the moment. With Go, Google was putting it into production from the first release, no?
From what I gather, one of the goals of a 1.0 release is that any subsequent releases will have enough tooling to painlessly upgrade to a new version. Something like a 'rust fix' command is surely how you'd want to implement that.
Making such a tool shouldn't be enormously painful, given the infrastructure to pretty-print your code exists in the rust compiler.
[1] https://bitbucket.org/jlahoda/jackpot30/wiki/Home
[2] https://netbeans.org/kb/docs/java/editor-inspect-transform.h...
Some of the things I hated about earlier versions have been resolved (such as lower case type names now being mixed case), but there are a lot of lingering stuff that I think make the language needlessly gnarly, in a Perl kind of way. For example, "::" just isn't a very good separator, visually; it litters the code with dots. The semicolon issue still irks me. Overall it's the proliferation of punctuation (the pointer prefixes, -> and =>, the new lifetime-ownership syntax, etc.) I consider problematic. Using underscore_separated_identifiers instead of camelCaseIdentifiers certainly works in Ruby, but Ruby has so little punctuation that it doesn't overwhelm, whereas with Rust it's just one more point off readability.
Looking at parts of the standard lib makes me unsure of whether it's just written in an obscure way (for example, getopts.rs [1]), or this is the way that Rust code will be written. I guess I'm apprehensive because modules that should be "simple" don't look simple, but remind me of unhappy hours spent reading Boost's source code. I know Rust is supposed to be lower-level than Go, but I always hoped that it would balance itself so that high-level stuff would feel appropriately high-level, but you could always dip lower into the metal to get the C-like feel.
Please pardon my wet blanket, the right thing would obviously have been to join rust-dev years ago. I'm still looking forward to doing something in Rust when it's production-ready.
[1] https://github.com/mozilla/rust/blob/incoming/src/libstd/get...
[1] https://github.com/mozilla/rust/tree/master/src/test/bench
brson and I have been discussing using stage0 LLVM for subsequent stages, so that LLVM itself won't have to be compiled. This should reduce the amount of time required to compile Rust by a lot.
Was their implementation having problems with it or was it rather a more deep-seated ideological choice?
Another reason might be so that self can be passed in a way the programmer prefers. Usually this appears to be `&self`, but it can also be passed in other ways.
Disclaimer: I work for Mozilla on Servo, and am still getting fully up to speed on Rust.
Looking at the change log, it seems that they also removed the "static" keyword, so that class vs member methods are distinguished by the presence of a first argument named self. A little further down, they mention ~self, &self, and @self. Those prefixes differentiate types of special purpose pointers.
So it seems the goal was not explicit self, so much as it was explicit pointer type annotations for self.
Less confusing for a user of when self is there and when it's not. Now it's always there and you don't have to know what the absence of self would indicate.
It was also not obvious that the implicit self type was immutable.
Finally, it let us remove "static" in a few places ("static" methods), reducing noise. It makes type implementations (impl Type { ... }) the same as regular modules, except that you can use "&self" and friends to declare methods.