7 ms·
let mut x = 2; let y = &8; // this didn't work, but now does x += y; Why is it desirable that that work? It seems like it will mask mistakes and make
by mkl 9y ago
let mut x = 2;
let y = &8;
// this didn't work, but now does
x += y;
Why is it desirable that that work? It seems like it will mask mistakes and make types more confusing.
- mark_edward 9y agoI agree. Some of the things done in the name of ergonomics just strike me as wrong and/or possibly misleading for learners. People who say Rust is hard to learn have always confused me. I learned programming in this order: scheme, C, C++, Haskell, Rust. I believe that if you go in another order it may make things more difficult, but some of these difficulties are inherent. To me, a reference to a thing is inherently different from the thing, and a systems language should make that clear. I didn't even like auto-deref, I felt like there should be an operator similar to thing->method() in C++ that can be chained so that references and indirection would always be syntactically clear and distinct, but the ergonomics on that won out.
- kibwen 9y agoThe change in question wasn't done because of ergonomics, it was done for consistency with the rest of the language. Read about it in the originating PR (which was not linked directly from the blog post): https://github.com/rust-lang/rust/pull/41336 https://github.com/rust-lang/rust/pull/41336
- coldtea 9y ago"People who say Rust is hard to learn have always confused me. I learned programming in this order: (...)" (proceeds to list a quite rare and outlier-ish learning sequence, and all in non-scripting languages to boot). Well, of course those people confused you. What you, who learned Scheme, C++ and Haskell before going to Rust, have in common with someone who only knows C or Java or only got his start in some scripting languages, so as to be able to relate with their "Rust is hard" experience?
- mmstick 9y agoI personally went from Go (slightly mingling with it) -> Rust 1.0 (wrote my first applications with it) and found it to be incredibly easy to learn in comparison to C, C++, Java, and even Python and JavaScript. Everything's pretty explicit and straightforward, and the API documentation and associated resources are stellar.
- Manishearth 9y ago> a systems language should make that clear Folks always say this but never really clarify why this should be the case. When doing low lever unsafe stuff Rust does indeed make it very clear if something is a pointer or not, and avoids weird coercions (even C doesn't do well here!) But for normal code, does it really matter if something is a pointer or not? In C++ already with by-ref and move values and stuff you have implicit pointers in many places that don't behave as pointers. Rust never goes the way of adding implicit allocations or implicit indirection; it only goes in the way of stripping it, which is rarely if ever a problem except when dealing with unsafe code (where Rust is more explicit on pointers anyway).
- kosinus 9y agoConsidering pointer arithmetic is unsafe, there are no other interpretations, I think? I can’t think of an example where this would mask a mistake in Rust. As for confusion, both are accepted. I imagine clippy will eventually have advice on this situation. For example, clippy also warns you about taking a reference that the compiler immediatly dereferences. I’m not sure what the long term plans are for clippy, but personally hope it’ll eventually be warnings in the official compiler.
- DSMan195276 9y ago> Considering pointer arithmetic is unsafe I just wanted to point out that this is largely a misconception. Rust, or the Rust creators, do not consider pointer arithmetic to be fundamentally `unsafe`, and the only reason `.offset()` is `unsafe` to begin with is due to optimization concerns[0]. `.wrapping_offset()` exists and is marked safe, despite achieving the exactly same thing as `.offset()` for the majority of scenarios[1], and more-over you can cast any pointer to an integer using only safe code, at which point you can perform all of your arithmetic on the integer and then cast it back also using only safe code[2]. The bottom line is that things like pointer arithmetic are generally not considered unsafe because the operation has defined semantics for what happens. It is only the point where you attempt to use the value, the dereference, that is `unsafe`, as that may blow-up if the value is an invalid memory location. [0] https://github.com/rust-lang/rust/issues/33813 https://github.com/rust-lang/rust/issues/33813 [1] https://play.rust-lang.org/?gist=c9c11545fac3a45550e6810cb579e4e9&version=stable https://play.rust-lang.org/?gist=c9c11545fac3a45550e6810cb57... An example that uses `.wrapping_offset` without `unsafe` to produce a segfault. [2] https://doc.rust-lang.org/book/first-edition/casting-between-types.html#pointer-casts https://doc.rust-lang.org/book/first-edition/casting-between...
- nicoburns 9y agoBut generally there's no point in doing pointer arithmetic unless you are going to deference the pointer at some point, right?
- DSMan195276 9y ago
- kibwen 9y agoIt's desirable from the standpoint of consistency, given that the following equivalent code has always worked: let mut x = 2; let y = &8; x = x + y; What mistakes could this be masking? I can't think of any.
- mkl 9y agoI didn't realise it already worked in other contexts. Mistakes in terms of understanding the code and writing what you think you're writing. I've only just begun learning Rust, and one of the most difficult things has been figuring out what types my variables have when everything is implicit and based on type inference. Variables that act both as pointers and non-pointers seem pretty confusing. It's like temporarily and invisibly turning off parts of the type-checker. ETA: To me it feels a bit like the icky type coercion magic some languages have that lets you write code that kind of works even though you don't understand what you're doing. I don't know Rust though, so this may be totally different.
- Jare 9y agoDon't worry, by the time the borrow checker is done with you, you will understand what you are doing like you've never before. This is a good thing.
- kibwen 9y agoIf you happen to be coming from C, keep in mind that integers in Rust don't coerce into anything else like they do in C; e.g. adding an 8-bit integer to a 32-bit integer (without an explicit cast) is a type error, `if 0` does not work, arithmetic ops on references never do pointer arithmetic, etc.
- fredmorcos 9y agoOkay, so I came from C and this part really put me off. Why? Because I like saying what I mean, and meaning what I say. Nothing hidden, nothing implicit. And C, as opposed to C++, does not allow you to say something you don't mean. Here is one C++ example, without looking for the signature of f(), there's no way to tell the answer. So essentially two pieces of identical code with identical input values and no external side effects can still give you different output. Ah C++, the garbage that you are. int x = 5; f(x); // WHAT IS THE VALUE OF X HERE? int x = 5; f(x); // WHAT IS THE VALUE OF X HERE? So why is Rust any better in this regard? Because at the end of the day, Rust deals with actual concrete types and values, the only thing references are good for is being references: they sometimes save you some copying and let you refer to stuff and that's pretty much it. So the "ref1 == ref2" operation is a deep equality check and not a "does ref1 point to the same object as ref2" check. Because sometimes objects in different places in memory can be semantically equal. So it's okay for obj1 to mean obj1, &obj1 to mean obj1, &&obj1 to mean obj1, etc... If you need raw pointers like you need in C, because you know the objects you want to compare are singletons, then you can always cast using &obj as *const Obj or &mut obj as *mut Obj But that's an escape hatch. BTW, this auto-dereferencing you're experiencing is part of the Deref trait if you ever want to overload it. But that's, in my own opinion, an escape hatch as well. All in all, unless you're doing very specific things, try to write your code in high-level semantics (meaning using these deep-equality rather than pointer-equality semantics), and then benchmark and find out which parts are hurting your performance. Rust allows you to do that and still get between very-reasonable-and-very-good speed.