exclusive range patterns #35712

oli-obk · 2016-08-16T11:14:23Z

adds .. patterns to the language under a feature gate (exclusive_range_pattern).

This allows turning

match i {
    0...9 => {},
    10...19 => {},
    20...29 => {},
    _ => {}
}

into

match i {
    0..10 => {},
    10..20 => {},
    20..30 => {},
    _ => {}
}

petrochenkov · 2016-08-17T22:49:03Z

src/librustc/hir/mod.rs

@@ -585,6 +586,8 @@ pub enum PatKind {
    Lit(P<Expr>),
    /// A range pattern, e.g. `1...2`
    Range(P<Expr>, P<Expr>),
+    /// A range pattern excluding the end, e.g. `1..2`
+    ExclusiveRange(P<Expr>, P<Expr>),


In most cases inclusive and exclusive ranges behave identically, it's probably more convenient to merge them into one variant Range(P<Expr>, P<Expr>, RangeKind).

I changed this, it's much less code and more readable code now 👍

src/libsyntax/parse/parser.rs

brson · 2016-11-09T01:32:31Z

This PR seems to have gone under the radar for a long time. Can somebody review?

Is this an implementation of an RFC. Is there a tracking issue?

brson · 2016-11-09T01:32:51Z

cc @rust-lang/compiler

oli-obk · 2016-11-09T08:11:40Z

No rfc or tracking issue, I thought it was just an oversight. But I can write an RFC...

nikomatsakis · 2016-11-17T21:14:40Z

There was an RFC, iirc, but @aturon has been having second thoughts on the syntax here, and wanting something more general.

nikomatsakis · 2016-11-17T22:31:47Z

My mistake: I thought this was adding ... expressions, not .. patterns.

aturon · 2016-11-17T22:33:42Z

Note: this was not covered by rust-lang/rfcs#1192

eddyb · 2016-11-17T22:34:13Z

Any thoughts on a.. or ..b?

nikomatsakis · 2016-11-17T22:34:32Z

Discussed in the @rust-lang/lang meeting:

This needs a tracking issue and feature-gate.
We feel OK landing this for now, as long as it is gated, because it seems that in any possible world this is desirable, but:
- we would be unlikely to stabilize until the question of how to handle ... is resolved
  - my preference is ..= (which generalizes to <..<, <..= and so forth)

bors · 2017-01-25T02:16:53Z

⌛ Testing commit 98fef41 with merge c0d0e68...

exclusive range patterns adds `..` patterns to the language under a feature gate (`exclusive_range_pattern`). This allows turning ``` rust match i { 0...9 => {}, 10...19 => {}, 20...29 => {}, _ => {} } ``` into ``` rust match i { 0..10 => {}, 10..20 => {}, 20..30 => {}, _ => {} } ```

bors · 2017-01-25T04:36:08Z

☀️ Test successful - status-appveyor, status-travis
Approved by: nikomatsakis
Pushing c0d0e68 to master...

@petrochenkov

Introduce `X..`, `..X`, and `..=X` range patterns Tracking issue: rust-lang#67264 Feature gate: `#![feature(half_open_range_patterns)]` --------------------------- In this PR, we introduce range-from (`X..`), range-to (`..X`), and range-to-inclusive (`..=X`) patterns. These correspond to the `RangeFrom`, `RangeTo`, and `RangeToInclusive` expression forms introduced with the same syntaxes. The correspondence is both syntactic and semantic (in the sense that e.g. a `X..` pattern matching on a scrutinee `s` holds exactly when `(X..).contains(&s)` holds). --------------------------- Noteworthy: - The compiler complexity added with this PR is around 10 lines (discounting new tests, which account for the large PR size). - `...X` is accepted syntactically with the same meaning as `..=X`. This is done primarily to simplify and unify the implementation & spec. If-and-when we decide to make `X...Y` a hard error on a new edition, we can do the same for `...X` patterns as well. - `X...` and `X..=` is rejected syntactically just like it is for the expression equivalents. We should perhaps make these into semantic restrictions (cc @petrochenkov). - In HAIR, these half-open ranges are represented by inserting the max/min values for the approprate types. That is, `X..` where `X: u8` would become `X..=u8::MAX` in HAIR (note the `..=` since `RangeFrom` includes the end). - Exhaustive integer / char matching does not (yet) allow for e.g. exhaustive matching on `0usize..` or `..5usize | 5..` (same idea for `isize`). This would be a substantially more invasive change, and could be added in some other PR. - The issues with slice pattern syntax has been resolved as we decided to use `..` to mean a "rest-pattern" and `[xs @ ..]` to bind the rest to a name in a slice pattern. - Like with rust-lang#35712, which provided `X..Y` range patterns, this is not yet backed up by an RFC. I'm providing this experimental implementation now to have something concrete to discuss. I would be happy to provide an RFC for this PR as well as for rust-lang#35712 to finalize and confirm the ideas with the larger community. Closes rust-lang/rfcs#947. --------------------------- r? @varkor cc @matthewjasper @oli-obk I would recommend reviewing this (in particular HAIR-lowering and pattern parsing changes) with whitespace changes ignored.

@petrochenkov

Introduce `X..`, `..X`, and `..=X` range patterns Tracking issue: rust-lang#67264 Feature gate: `#![feature(half_open_range_patterns)]` --------------------------- In this PR, we introduce range-from (`X..`), range-to (`..X`), and range-to-inclusive (`..=X`) patterns. These correspond to the `RangeFrom`, `RangeTo`, and `RangeToInclusive` expression forms introduced with the same syntaxes. The correspondence is both syntactic and semantic (in the sense that e.g. a `X..` pattern matching on a scrutinee `s` holds exactly when `(X..).contains(&s)` holds). --------------------------- Noteworthy: - The compiler complexity added with this PR is around 10 lines (discounting new tests, which account for the large PR size). - `...X` is accepted syntactically with the same meaning as `..=X`. This is done primarily to simplify and unify the implementation & spec. If-and-when we decide to make `X...Y` a hard error on a new edition, we can do the same for `...X` patterns as well. - `X...` and `X..=` is rejected syntactically just like it is for the expression equivalents. We should perhaps make these into semantic restrictions (cc @petrochenkov). - In HAIR, these half-open ranges are represented by inserting the max/min values for the approprate types. That is, `X..` where `X: u8` would become `X..=u8::MAX` in HAIR (note the `..=` since `RangeFrom` includes the end). - Exhaustive integer / char matching does not (yet) allow for e.g. exhaustive matching on `0usize..` or `..5usize | 5..` (same idea for `isize`). This would be a substantially more invasive change, and could be added in some other PR. - The issues with slice pattern syntax has been resolved as we decided to use `..` to mean a "rest-pattern" and `[xs @ ..]` to bind the rest to a name in a slice pattern. - Like with rust-lang#35712, which provided `X..Y` range patterns, this is not yet backed up by an RFC. I'm providing this experimental implementation now to have something concrete to discuss. I would be happy to provide an RFC for this PR as well as for rust-lang#35712 to finalize and confirm the ideas with the larger community. Closes rust-lang/rfcs#947. --------------------------- r? @varkor cc @matthewjasper @oli-obk I would recommend reviewing this (in particular HAIR-lowering and pattern parsing changes) with whitespace changes ignored.

@petrochenkov

Introduce `X..`, `..X`, and `..=X` range patterns Tracking issue: rust-lang#67264 Feature gate: `#![feature(half_open_range_patterns)]` --------------------------- In this PR, we introduce range-from (`X..`), range-to (`..X`), and range-to-inclusive (`..=X`) patterns. These correspond to the `RangeFrom`, `RangeTo`, and `RangeToInclusive` expression forms introduced with the same syntaxes. The correspondence is both syntactic and semantic (in the sense that e.g. a `X..` pattern matching on a scrutinee `s` holds exactly when `(X..).contains(&s)` holds). --------------------------- Noteworthy: - The compiler complexity added with this PR is around 10 lines (discounting new tests, which account for the large PR size). - `...X` is accepted syntactically with the same meaning as `..=X`. This is done primarily to simplify and unify the implementation & spec. If-and-when we decide to make `X...Y` a hard error on a new edition, we can do the same for `...X` patterns as well. - `X...` and `X..=` is rejected syntactically just like it is for the expression equivalents. We should perhaps make these into semantic restrictions (cc @petrochenkov). - In HAIR, these half-open ranges are represented by inserting the max/min values for the approprate types. That is, `X..` where `X: u8` would become `X..=u8::MAX` in HAIR (note the `..=` since `RangeFrom` includes the end). - Exhaustive integer / char matching does not (yet) allow for e.g. exhaustive matching on `0usize..` or `..5usize | 5..` (same idea for `isize`). This would be a substantially more invasive change, and could be added in some other PR. - The issues with slice pattern syntax has been resolved as we decided to use `..` to mean a "rest-pattern" and `[xs @ ..]` to bind the rest to a name in a slice pattern. - Like with rust-lang#35712, which provided `X..Y` range patterns, this is not yet backed up by an RFC. I'm providing this experimental implementation now to have something concrete to discuss. I would be happy to provide an RFC for this PR as well as for rust-lang#35712 to finalize and confirm the ideas with the larger community. Closes rust-lang/rfcs#947. --------------------------- r? @varkor cc @matthewjasper @oli-obk I would recommend reviewing this (in particular HAIR-lowering and pattern parsing changes) with whitespace changes ignored.

@petrochenkov

Introduce `X..`, `..X`, and `..=X` range patterns Tracking issue: rust-lang#67264 Feature gate: `#![feature(half_open_range_patterns)]` --------------------------- In this PR, we introduce range-from (`X..`), range-to (`..X`), and range-to-inclusive (`..=X`) patterns. These correspond to the `RangeFrom`, `RangeTo`, and `RangeToInclusive` expression forms introduced with the same syntaxes. The correspondence is both syntactic and semantic (in the sense that e.g. a `X..` pattern matching on a scrutinee `s` holds exactly when `(X..).contains(&s)` holds). --------------------------- Noteworthy: - The compiler complexity added with this PR is around 10 lines (discounting new tests, which account for the large PR size). - `...X` is accepted syntactically with the same meaning as `..=X`. This is done primarily to simplify and unify the implementation & spec. If-and-when we decide to make `X...Y` a hard error on a new edition, we can do the same for `...X` patterns as well. - `X...` and `X..=` is rejected syntactically just like it is for the expression equivalents. We should perhaps make these into semantic restrictions (cc @petrochenkov). - In HAIR, these half-open ranges are represented by inserting the max/min values for the approprate types. That is, `X..` where `X: u8` would become `X..=u8::MAX` in HAIR (note the `..=` since `RangeFrom` includes the end). - Exhaustive integer / char matching does not (yet) allow for e.g. exhaustive matching on `0usize..` or `..5usize | 5..` (same idea for `isize`). This would be a substantially more invasive change, and could be added in some other PR. - The issues with slice pattern syntax has been resolved as we decided to use `..` to mean a "rest-pattern" and `[xs @ ..]` to bind the rest to a name in a slice pattern. - Like with rust-lang#35712, which provided `X..Y` range patterns, this is not yet backed up by an RFC. I'm providing this experimental implementation now to have something concrete to discuss. I would be happy to provide an RFC for this PR as well as for rust-lang#35712 to finalize and confirm the ideas with the larger community. Closes rust-lang/rfcs#947. --------------------------- r? @varkor cc @matthewjasper @oli-obk I would recommend reviewing this (in particular HAIR-lowering and pattern parsing changes) with whitespace changes ignored.

@petrochenkov

Introduce `X..`, `..X`, and `..=X` range patterns Tracking issue: rust-lang#67264 Feature gate: `#![feature(half_open_range_patterns)]` --------------------------- In this PR, we introduce range-from (`X..`), range-to (`..X`), and range-to-inclusive (`..=X`) patterns. These correspond to the `RangeFrom`, `RangeTo`, and `RangeToInclusive` expression forms introduced with the same syntaxes. The correspondence is both syntactic and semantic (in the sense that e.g. a `X..` pattern matching on a scrutinee `s` holds exactly when `(X..).contains(&s)` holds). --------------------------- Noteworthy: - The compiler complexity added with this PR is around 10 lines (discounting new tests, which account for the large PR size). - `...X` is accepted syntactically with the same meaning as `..=X`. This is done primarily to simplify and unify the implementation & spec. If-and-when we decide to make `X...Y` a hard error on a new edition, we can do the same for `...X` patterns as well. - `X...` and `X..=` is rejected syntactically just like it is for the expression equivalents. We should perhaps make these into semantic restrictions (cc @petrochenkov). - In HAIR, these half-open ranges are represented by inserting the max/min values for the approprate types. That is, `X..` where `X: u8` would become `X..=u8::MAX` in HAIR (note the `..=` since `RangeFrom` includes the end). - Exhaustive integer / char matching does not (yet) allow for e.g. exhaustive matching on `0usize..` or `..5usize | 5..` (same idea for `isize`). This would be a substantially more invasive change, and could be added in some other PR. - The issues with slice pattern syntax has been resolved as we decided to use `..` to mean a "rest-pattern" and `[xs @ ..]` to bind the rest to a name in a slice pattern. - Like with rust-lang#35712, which provided `X..Y` range patterns, this is not yet backed up by an RFC. I'm providing this experimental implementation now to have something concrete to discuss. I would be happy to provide an RFC for this PR as well as for rust-lang#35712 to finalize and confirm the ideas with the larger community. Closes rust-lang/rfcs#947. --------------------------- r? @varkor cc @matthewjasper @oli-obk I would recommend reviewing this (in particular HAIR-lowering and pattern parsing changes) with whitespace changes ignored.

…r=joshtriplett Stabilize "RangeFrom" patterns in 1.55 Implements a partial stabilization of rust-lang#67264 and rust-lang#37854. Reference PR: rust-lang/reference#900 # Stabilization Report This stabilizes the `X..` pattern, shown as such, offering an exhaustive match for unsigned integers: ```rust match x as u32 { 0 => println!("zero!"), 1.. => println!("positive number!"), } ``` Currently if a Rust author wants to write such a match on an integer, they must use `1..={integer}::MAX` . By allowing a "RangeFrom" style pattern, this simplifies the match to not require the MAX path and thus not require specifically repeating the type inside the match, allowing for easier refactoring. This is particularly useful for instances like the above case, where different behavior on "0" vs. "1 or any positive number" is desired, and the actual MAX is unimportant. Notably, this excepts slice patterns which include half-open ranges from stabilization, as the wisdom of those is still subject to some debate. ## Practical Applications Instances of this specific usage have appeared in the compiler: https://github.com/rust-lang/rust/blob/16143d10679537d3fde4247e15334e78ad9d55b9/compiler/rustc_middle/src/ty/inhabitedness/mod.rs#L219 https://github.com/rust-lang/rust/blob/673d0db5e393e9c64897005b470bfeb6d5aec61b/compiler/rustc_ty_utils/src/ty.rs#L524 And I have noticed there are also a handful of "in the wild" users who have deployed it to similar effect, especially in the case of rejecting any value of a certain number or greater. It simply makes it much more ergonomic to write an irrefutable match, as done in Katholieke Universiteit Leuven's [SCALE and MAMBA project](https://github.com/KULeuven-COSIC/SCALE-MAMBA/blob/05e5db00d553573534258585651c525d0da5f83f/WebAssembly/scale_std/src/fixed_point.rs#L685-L695). ## Tests There were already many tests in [src/test/ui/half-open-range/patterns](https://github.com/rust-lang/rust/tree/90a2e5e3fe59a254d4d707aa291517b3791ea5a6/src/test/ui/half-open-range-patterns), as well as [generic pattern tests that test the `exclusive_range_pattern` feature](https://github.com/rust-lang/rust/blob/673d0db5e393e9c64897005b470bfeb6d5aec61b/src/test/ui/pattern/usefulness/integer-ranges/reachability.rs), many dating back to the feature's introduction and remaining standing to this day. However, this stabilization comes with some additional tests to explore the... sometimes interesting behavior of interactions with other patterns. e.g. There is, at least, a mild diagnostic improvement in some edge cases, because before now, the pattern `0..=(5+1)` encounters the `half_open_range_patterns` feature gate and can thus emit the request to enable the feature flag, while also emitting the "inclusive range with no end" diagnostic. There is no intent to allow an `X..=` pattern that I am aware of, so removing the flag request is a strict improvement. The arrival of the `J | K` "or" pattern also enables some odd formations. Some of the behavior tested for here is derived from experiments in this [Playground](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=58777b3c715c85165ac4a70d93efeefc) example, linked at rust-lang#67264 (comment), which may be useful to reference to observe the current behavior more closely. In addition tests constituting an explanation of the "slicing range patterns" syntax issue are included in this PR. ## Desiderata The exclusive range patterns and half-open range patterns are fairly strongly requested by many authors, as they make some patterns much more natural to write, but there is disagreement regarding the "closed" exclusive range pattern or the "RangeTo" pattern, especially where it creates "off by one" gaps in the presence of a "catch-all" wildcard case. Also, there are obviously no range analyses in place that will force diagnostics for e.g. highly overlapping matches. I believe these should be warned on, ideally, and I think it would be reasonable to consider such a blocker to stabilizing this feature, but there is no technical issue with the feature as-is from the purely syntactic perspective as such overlapping or missed matches can already be generated today with such a catch-all case. And part of the "point" of the feature, at least from my view, is to make it easier to omit wildcard matches: a pattern with such an "open" match produces an irrefutable match and does not need the wild card case, making it easier to benefit from exhaustiveness checking. ## History - Implemented: - Partially via exclusive ranges: rust-lang#35712 - Fully with half-open ranges: rust-lang#67258 - Unresolved Questions: - The precedence concerns of rust-lang#48501 were considered as likely requiring adjustment but probably wanting a uniform consistent change across all pattern styles, given rust-lang#67264 (comment), but it is still unknown what changes might be desired - How we want to handle slice patterns in ranges seems to be an open question still, as witnessed in the discussion of this PR! I checked but I couldn't actually find an RFC for this, and given "approved provisionally by lang team without an RFC", I believe this might require an RFC before it can land? Unsure of procedure here, on account of this being stabilizing a subset of a feature of syntax. r? `@scottmcm`

rust-highfive assigned arielb1 Aug 16, 2016

This comment has been minimized.

Sign in to view

petrochenkov reviewed Aug 17, 2016
View reviewed changes

This comment has been minimized.

Sign in to view

oli-obk force-pushed the exclusive_range_patterns branch 2 times, most recently from 5d9114a to a033745 Compare September 6, 2016 12:57

This comment has been minimized.

Sign in to view

oli-obk force-pushed the exclusive_range_patterns branch from a033745 to a244de1 Compare September 22, 2016 10:42

This comment has been minimized.

Sign in to view

oli-obk force-pushed the exclusive_range_patterns branch from a244de1 to 111f898 Compare October 25, 2016 10:52

This comment has been minimized.

Sign in to view

petrochenkov reviewed Oct 27, 2016

View reviewed changes

src/libsyntax/parse/parser.rs Show resolved Hide resolved

oli-obk force-pushed the exclusive_range_patterns branch from 111f898 to f8211a2 Compare November 7, 2016 11:47

brson added I-nominated T-lang Relevant to the language team, which will review and decide on the PR/issue. labels Nov 9, 2016

brson added T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. and removed T-lang Relevant to the language team, which will review and decide on the PR/issue. labels Nov 9, 2016

brson added the relnotes Marks issues that should be documented in the release notes of the next release. label Nov 11, 2016

nikomatsakis added T-lang Relevant to the language team, which will review and decide on the PR/issue. and removed T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Nov 17, 2016

nikomatsakis removed the I-nominated label Nov 17, 2016

oli-obk mentioned this pull request Nov 18, 2016

Tracking issue for exclusive range patterns #37854

Closed

This comment has been minimized.

Sign in to view

bors merged commit 98fef41 into rust-lang:master Jan 25, 2017

oli-obk deleted the exclusive_range_patterns branch January 25, 2017 12:33

tomprince mentioned this pull request Jan 26, 2017

failed to compile clippy v0.0.111 rust-lang/rust-clippy#1476

Closed

Arnavion mentioned this pull request Apr 25, 2017

Support parsing half-open ranges in patterns. dtolnay/syn#128

Merged

Centril mentioned this pull request Dec 12, 2019

Introduce X.., ..X, and ..=X range patterns #67258

Merged

Centril added the F-exclusive_range_pattern `#![feature(exclusive_range_pattern)]` label Dec 12, 2019

str4d mentioned this pull request Mar 6, 2021

Orchard key components zcash/orchard#40

Merged

workingjubilee mentioned this pull request May 4, 2021

Stabilize "RangeFrom" patterns in 1.55 #83918

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

exclusive range patterns #35712

exclusive range patterns #35712

oli-obk commented Aug 16, 2016 •

edited

Loading

This comment has been minimized.

petrochenkov Aug 17, 2016

oli-obk Aug 18, 2016 •

edited

Loading

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

brson commented Nov 9, 2016

brson commented Nov 9, 2016

oli-obk commented Nov 9, 2016

nikomatsakis commented Nov 17, 2016

nikomatsakis commented Nov 17, 2016

aturon commented Nov 17, 2016

eddyb commented Nov 17, 2016

nikomatsakis commented Nov 17, 2016

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

bors commented Jan 25, 2017

bors commented Jan 25, 2017

exclusive range patterns #35712

exclusive range patterns #35712

Conversation

oli-obk commented Aug 16, 2016 • edited Loading

This comment has been minimized.

petrochenkov Aug 17, 2016

Choose a reason for hiding this comment

oli-obk Aug 18, 2016 • edited Loading

Choose a reason for hiding this comment

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

brson commented Nov 9, 2016

brson commented Nov 9, 2016

oli-obk commented Nov 9, 2016

nikomatsakis commented Nov 17, 2016

nikomatsakis commented Nov 17, 2016

aturon commented Nov 17, 2016

eddyb commented Nov 17, 2016

nikomatsakis commented Nov 17, 2016

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

bors commented Jan 25, 2017

bors commented Jan 25, 2017

oli-obk commented Aug 16, 2016 •

edited

Loading

oli-obk Aug 18, 2016 •

edited

Loading