News for hackers. Stuff that matters.
Re:Comparison between Rust and D by eudox on Saturday June 25, 2016 @10:05AM (#11976349)
Those are two different bindings. That is,

  fn main() {
    let x = true;
    {
      let x = false;
    }
  }
Since you don't use let for assignment, it's a non-problem. And it can be useful when you're doing some computation where you want to keep intermediate variables (for debugging or clarity), and rather than think of the proper name for each, you just successively bind the same name.
Re:Comparison between Rust and D by teamhappy on Saturday June 25, 2016 @10:36AM (#11976435)
I know a lot of people really like shadowing. I obviously don't. GHC has an option to emit a warning and if Rusts compiler adds one for it as well (maybe it has one by know? I don't know) I guess I'm okay with it.
Re:Comparison between Rust and D by steveklabnik on Saturday June 25, 2016 @11:09AM (#11976555)
Clippy has a lint, but it's not turned on by default, even in Clippy.
Re:Comparison between Rust and D by Manishearth on Saturday June 25, 2016 @11:33AM (#11976663)
We have three, in fact, which disallow various kinds of shadowing. For example, some people like `let x = <expr containing x>` shadows but not `let x = <totally unrelated>`. But everyone has wildly different style choices here so we leave all three off by default and you can turn them on if you want. I have yet to see a bug in Rust code caused by shadowing, though.
Re:Comparison between Rust and D by sixbrx on Saturday June 25, 2016 @10:16AM (#11976374)
Very useful indeed when you want a canonical or corrected (or otherwise "improved") version of a value and want to make sure that the original can't accidentally be used in what follows (which can be a hard to detect bug).
Re:Comparison between Rust and D by eudox on Saturday June 25, 2016 @10:29AM (#11976410)
Yes, a common refinement pattern in code is (pseudocode):

  def fn(object):
    let object = predicate(object) ? modify(object) : error();
    // do something with the refined object
Or something along those lines.
Re:Comparison between Rust and D by tormeh on Saturday June 25, 2016 @01:23PM (#11977100)

  Can I write
   let x = 1;
   let x = x + 1;
?
Re:Comparison between Rust and D by steveklabnik on Saturday June 25, 2016 @01:25PM (#11977107)
Yes.
Re:Comparison between Rust and D by tormeh on Saturday June 25, 2016 @01:38PM (#11977158)
And is the behavior exactly the same as it would be if I omitted "let" on the second code line? If the answer is yes, isn't it just mutability with different syntax then?

I would guess shadowing wouldn't affect values shared with a different thread, because it's technically a new value, but in single-thread use it would be equivalent to assignment.

Re:Comparison between Rust and D by steveklabnik on Saturday June 25, 2016 @02:38PM (#11977410)
The behavior is not the same. It's a new variable, entirely. So you'll have two integers on the stack, one of them is not accessible any more. You can see this difference if you add a scope around the second x, and then print the value of the original x after it goes out of scope.

Consider this program:

    fn main() {
        let x = 5;
        let r1 = &x;
        let x = x + 1;
        let r2 = &x;
        
        println!("r1: {:p}", r1);
        println!("r2: {:p}", r2);
    }
This will print something like

  r1: 0x7fff955e3dfc
  r2: 0x7fff955e3dec
Note that while you can't access the original x, it's still there, and references to it still work. Because the value of x was copied, not mutated.

Also, given compiler details like SSA, I'd argue that in a certain sense, mutation is similar to this, rather than this being similar to mutation...

Re:Comparison between Rust and D by yokohummer7 on Saturday June 25, 2016 @01:49PM (#11977211)
It doesn't have the same semantics, because even after introducing the new variable, it is still immutable. So you cannot accidentally modify the new variable. e.g.,

  let x = 1;
  let x = x + 1;
  x = 99; // Error: you can't accidentally modify the immutable variable `x`

  let mut x = 1;
  x = x + 1;
  x = 99; // Ok
You can even turn back a mutable varaible into an immutable variable, like this:

  let mut x = 1;
  x = x + 1;
  let x = x;
  x = 99; // Error: `x` became immutable
This can be useful to "pin" the variable after a large number of calculations done to it.
Re:Comparison between Rust and D by kibwen on Saturday June 25, 2016 @04:52PM (#11977931)

  > isn't it just mutability with different syntax then?
For one thing, in order to take a mutable reference to a binding, that binding must be declared as `mut`.

    let mut a = 2;
    let b = 3;
    let x = &mut a;
    // let y = &mut b;  // error: cannot borrow immutable local variable `b` as mutable
Re:Comparison between Rust and D by solidsnack9000 on Saturday June 25, 2016 @01:48PM (#11977204)
> I would guess shadowing wouldn't affect values shared with a different thread...

That is actually a big deal, though.