8 ms·
Announcing Rust 1.9
- mtgx 10y agoWow, almost 2.0 already. Any major features reserved for 2.0 or will it be just another typical release like 1.8 or 1.9, more or less?
- Nekit1234007 10y agoNext release will most likely be 1.10. As per semver.
- steveklabnik 10y agoThe next release will be 1.10, not 2.0. There are no current plans for a 2.0 at this time.
- bryanray 10y agoLooks like a great release. Controlled unwinding looks very interesting. #GreatJobRustTeam
- asp2insp 10y agoThe time complexity of comparing variables for equivalence during type unification is reduced from O(n!) to O(n). As a result, some programming patterns compile much, much more quickly. I love this. Not just my code compiling more quickly, but the underlying implementation is super interesting.
- kvark 10y agoIs this something seen frequently in user code, or just an edge case? I'd love to get even faster with my libraries compiling, but honestly the continuous improvements in compile speed over the last half a year have already made me happy :)
- tatterdemalion 10y agoIts an edge case for the `n` to get high enough for it make a big impact.
- euyyn 10y agoAnd depending on the multiplying constant, it could mean everything is slower than before _until_ you reach a high enough n. EDIT: The PR that added the change claims it was done well, though :) https://github.com/rust-lang/rust/pull/32062 https://github.com/rust-lang/rust/pull/32062
- topspin 10y agoIndeed. It's hard to miss just how much better rustc performance has become recently. As I've watched this I been left wondering; is it just the blood and sweat of the compiler developers doing this or is the language somehow inherently efficient to compile? I know there are other, much older languages that seem unable to deal with their compiler performance problems.
- steveklabnik 10y agoIt is a combination of both. We took performance into consideration when designing all aspects of the langauge, and so we've laid a lot of groundwork. The gains have come because the compiler had so much technical debt; imagine a hundreds of thousands of LOC codebase where the language changes out from under it on a weekly/daily basis. So every since 1.0, and even before, really, it's been paying off debt, and doing things in better ways. And there's more coming. Incremental recompilation will make after-the-first compiles go even faster. But all of that takes tons of work.
- Gankro 10y agoOn the other hand, niko has described trait resolution as "basically prolog", so that's something you can push to perform as degenerately bad as you want (the recent addition of specialization only making things worse). The issue is just how degenerately bad "most" code is -- and I think that hinges a lot on how excited the word "higher" gets you vis-a-vis expressing your programs. If you think C# is a pretty cool type system that doesn't afraid of anything you'll probably be fine. If you think scala or haskell with All The GHC Extensions is where it's at... watch out.
- wyldfire 10y agoUnexpected problems are bugs: they arise due to a contract or assertion being violated. Speaking of which, DBC [1] would be an awesome feature for consideration. It's one of relatively few areas where D is superior to Rust IMO. [1] https://github.com/rust-lang/rfcs/issues/1077 https://github.com/rust-lang/rfcs/issues/1077
- Animats 10y agocatch_unwind Exceptions, at last! Not very good exceptions, though. About at the level of Go's "recover()". If this is done right, so that locks unlock, destructors run, and reference counts are updated, it's all the complexity of exceptions for some of the benefits. I'd rather have real exceptions than sort-of exceptions.
- vvanders 10y agoSo much snark. Error handling is something Rust does really well. Having used exception languages quite a bit I much prefer the forced handled return values. Exceptions don't map well to the type of handling patterns like and_then(...), or_else(...) and the like which I find much more ergonomic and clean.
- valarauca1 10y agoExceptions can also be a pain to deal with in lazy Iterators. Either every lambda needs to be a try statement, or you need state.
- deleted 10y ago[deleted]
- tatterdemalion 10y agoUsers are strongly and emphatically discouraged from using this for expection-style control flow. This is for managing crashes at the thread or FFI boundary. In general, we're very happy with monadic error handling and don't want exceptions.
- steveklabnik 10y agoThese are not exceptions, and are not intended to be used like exceptions. They may have an implementation that's kinda sorta similar to exceptions, but that doesn't make them exceptions.
- kibwen 10y agoThese are not exceptions, and I guarantee that you and your users will be very, very miserable if you try to use them as such. :P This is primarily for preventing undefined behavior at FFI boundaries, there are no affordances in the language that make this mechanism anywhere comparable to a real exceptions system from, say, Python.
- shmerl 10y agoProgress on specialization is good. > Altogether, this relatively small extension to the trait system yields benefits for performance and code reuse, and it lays the groundwork for an "efficient inheritance" scheme that is largely based on the trait system
- JoshTriplett 10y agoI'm really looking forward to the next stable version after this, which will hopefully stabilize the new '?' syntax for 'try!'.
- steveklabnik 10y agoI can guarantee you it will not. ? is still unstable, and since the release of 1.9 means that 1.10 is in beta, it will not be in 1.10.
- JoshTriplett 10y agoWhat's the remaining work needed to make '?' no longer unstable?
- tatterdemalion 10y agoThe main remaining work on the RFC is to implement the `catch` construct. Here's the tracking issue: https://github.com/rust-lang/rust/issues/31436 https://github.com/rust-lang/rust/issues/31436 However, stabilizing `?` is not blocked on any particular work as much as on the relevant team deciding its a good feature without big bugs that they are happy to see made permanent. Given that a minority of the community opposes `?` vehemently, this process will probably move slowly. Personally, I opt into question mark in all of my nightly code and I absolutely love it. I had a case last night actually where I really wanted `catch` also.
- steveklabnik 10y agoWell for one, there's a huuuuuge unresolved question: should it work for Option as well as Result? If we stabilized just the Result version, would we lock out the possibility of extending it in the future? Just in general, it is a huge, and widely debated new feature that only landed recently. It needs more time before we can consider stabilizing it. One of the longest-running and most-commented RFCs in Rust history deserves to not just be made stable as quickly as possible, but to take it slow and make sure we get it right.
- MichaelGG 10y agoI don't understand the announcement on panics. Hasn't it always been the case that thread boundaries (via spawn) could contain panics? It's also used to have the incorrect default that such panics were silently ignored. .NET made this same mistake: background threads could silently die. They reversed and made a breaking change so any uncaught exception kills the process. I'd imagine Rust will do so by encouraging a different API if they haven't already. (I opened an RFC on this last year, but I didn't understand enough Rust and made a mess of it. But still a great experience, speaking to the very kind and professional community. In particular several people were patient, but firm, in explaining my misunderstandings.)
- steveklabnik 10y ago> Hasn't it always been the case that thread boundaries (via spawn) > could contain panics? Yes. This lets you catch an unwinding panic from inside the thread itself, rather than observing it get killed from the outside. In Rust, they're not silently ignored: `join()` returns a `Result`, which has a `must_use` attribute, which will warn if you don't do something with it.
- MichaelGG 10y agoThanks for the clarification. On thread panics: Suppose you have a long-running thread that's updating shared variable. You don't call join on it; just drop it, so it's detached, running in the background. If that thread crashes (and isn't in e.g. a mutex so it can't poison), your process will continue on in an invalid state. Yes, you could add code to notice the panic and abort the process, but by default, it'll silently fail, right?
- steveklabnik 10y ago> and isn't in eg a mutex so it can't poison Well, Rust makes sure that you have _some_ kind of concurrency primitive in place to make this safe. It's also worth mentioning that Rust is concerned about preventing memory safety bugs, not every single kind of bug ever. I mean, we want to encourage robust code, but we don't make the claim that Rust solves every kind of bug possible with the type system.
- jeffdavis 10y agoExcited about unwinding becoming stable. I am hacking on postgres-extension.rs, which allows writing postgres extensions in rust. This will mean that postgres could call into rust code, then rust could call back into postgres code, and that postgres code could throw an error, and rust could safely unwind and re-throw. Cool!!
- greatidea 10y agoNot yet a Rust programmer but Rust does look like an excellent language for PostgreSQL extensions.
- sbuttgereit 10y agoVery much pleased to see you working on this. I've been thinking that Rust would make an excellent language for those of us that want to get a bit closer to C-like backed functions and such, but aren't really C programmers. While Rust has it's own learning curve to be sure and isn't magic, the compiler can save those of us familiar with less systemy languages from mistakes we wouldn't otherwise be sensitive to.
- jeffdavis 10y agoBy "hacking on" I mean "submitted a pull request to Daniel Fagnan's project". I didn't mean to take credit. But I do plan to keep improving it.
- spion 10y agoI don't know how this unexpected vs expected errors philosophy gets propagated, but to me it always looked suspicious. Take array bounds for example: what if you have an API that lets users send a list of image transformations, and the user requests a face-detect crop, followed by a fixed crop with a given x, y, w, h. Clearly your code can get out of (2D) array bounds with the fixed crop (if the image is such that the face-detect crop ends up small enough). Suddenly the thing that was "unexpected" at the array level becomes very much expected at the higher API level. So the API provider can't decide whether an error is expected or not. Only the API consumer can do that. Applying this further, a mid-level consumer cannot (always) make the decision either. Which is why exceptions work the way they do: bubble until a consumer makes a decision, otherwise consider the whole error unexpected. Mid-level consumers should use finally (or even better, defer!) to clean up any potentially bad state. I think Swift got this right. What you care about isn't what exactly was thrown (checked, typed exceptions) but the critical thing is whether a call throws or not. This informs us whether to use finally/defer to clean up. The rest of error handling is easy: we handle errors we expect, we fix errors we forgot to expect, but either way we don't crash for clean up because finally/defer/destructors take care of that.
- nickm12 10y agoI don't understand your example. The API provider has to determine the contract and decide whether out-of-bounds crops are supported or not. If they are supported, then an out-of-bounds panic is a bug in the API. If they are not supported, then an out-of-bounds panic is a bug in the caller. In either case, the exception is unexpected and due to someone not following the contract.
- blaisio 10y agoYour example doesn't make sense. Keep in mind that an out of bounds array access can cause a lot of problems; in the best case, it would cause a segfault, and in the worst it would allow for code injection. So there isn't really a case where accessing an array out of bounds makes sense. That's where the idea of "expected vs unexpected errors" comes from. Another way to think about it is that some errors can be handled and some can't. For example, most of the time you can't "fix" a segfault, so it makes sense for that to just crash the program.