Hacker News Reader

Comment by anuragsoni | Hacker News Reader

Great to see Rustup reach 1.0 release. I like how easy it makes to test out different versions of rust and its toolchains.

I like the '..' addition for structs. It definitely improved the pattern matching over structs.

  let p = Point { x: 0, y: 1, z: 2 };
  match p {
    Point { x, .. } => println!("x is {}", x),
  }

Congrats to the Rust Team for another good release!!

View on HN

There must be some interesting reason why ".." and not the more common "..." - I wonder what?

They probably 'copied' Haskell here, which also uses "..".

Haskell doesn't have this feature though. I mean it does, but you can just leave out the ones you don't want matched, you don't have to put in any dots.

It's less to type. The double period is already used for lots of other things in the language, so it feels like the correct choice.

Reading through, they treat a range (like 1 .. 10 ) as pattern matching 1 2 3 4 5 6 7 8 9 10, with .. representing 2 3 4 5 6 7 8 9.

In that light, it actually makes sense.

Ah of course, that is quite widely used (e.g. Perl). If you already have that, I can see why you'd reuse the same token.

(edit: ok, I see from other replies that it's not that simple)

Minor correction, to match a range the syntax would be

  1 ... 10

No particular reason.

`..` and `...` both exist in the language, `..` is exclusive range and `...` is inclusive range. `..` is only in expressions right now, whereas `...` is only in patterns. Eventually, both will be available everywhere, possibly. At very least, `..` in patterns is getting added soon.

Since this is a pattern thing, probably `..` was chosen when `...` was the only range available in patterns, to distinguish this from that range pattern more. However, `..` will now be available in patterns, so its just historical.

(This is a longstanding feature, what's changed is just making it apply to more patterns.)

I've seen the "..." used for matching a range of values, whereas ".." is used in other places where we disregard a value while patter matching.

I'm sure someone from the rust team can give a better answer, but to me this change looks like it was just bringing the pattern matching for structs to be consistent with other uses of ".."

Relevant RFC: https://github.com/rust-lang/rfcs/blob/master/text/1492-dotd...

Question from someone who don't know Rust: Why two dots instead of an ellipsis (three)?

Three dots doesn't look like an ellipsis in a monospaced font, it's far too wide.

It can if you use a monospaced font with ligatures.

Take a look at Fira Code [1]. I use it in Vim and IntelliJ, and it looks great with Rust and other functional languages.

[1] https://github.com/tonsky/FiraCode

Well, I'm sure you know what I meant.

I'm pretty sure he did know what you meant, and offered a serious response. I think he's suggesting that perhaps the aesthetics of the ellipsis is what prevented it from being selected.

It's already a keyword or operator (not sure which) used in range notation (1..2); why add a new operator when an old one will do?

Three dots are for inclusive ranges, two for exclusive

This is such a win for pattern matching! I tried using this exact syntax last month and I was sad to see it didn't exist. It feels so natural to see it now.

Rust is such an awesome language. Every design decision feels so right. Go, Rust, go!

Reply on news.ycombinator.com