Skip to content

Documenting binding syntax for pattern matching #10917

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 2 commits into from
Closed
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
42 changes: 41 additions & 1 deletion doc/tutorial.md
Original file line number Diff line number Diff line change
Expand Up @@ -476,7 +476,7 @@ can be expressed with two dots, as in `M..N`. The underscore (`_`) is
a wildcard pattern that matches any single value. (`..`) is a different
wildcard that can match one or more fields in an `enum` variant.

The patterns in a match arm are followed by a fat arrow, `=>`, then an
The patterns in a `match` arm are followed by a fat arrow, `=>`, then an
expression to evaluate. Each case is separated by commas. It's often
convenient to use a block expression for each case, in which case the
commas are optional.
Expand Down Expand Up @@ -542,6 +542,45 @@ Let bindings only work with _irrefutable_ patterns: that is, patterns
that can never fail to match. This excludes `let` from matching
literals and most `enum` variants.

The pattern of a `match` arm can also be bound to a variable for use in the
`match` arm's expression. In Haskell, this is known as an [as-pattern].


~~~~
match (1, 2) {
c @ (a, b) => println!("{} {} {:?}", a, b, c)
}
~~~~

This will print `1 2 (1, 2)`. `c` is bound to the pattern `(a, b)`, and as
`a` and `b` are respectively bound to `1` and `2`, `c` comes out to `(1, 2)`.
The bound variable `c` is only usable in the corresponding arm.

Pattern binding can also be used in conjuntion with guard clauses.

~~~~
match (1, 2) {
c @ (a, b) if a > 0 => println!("First arm {:?}", c),
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It would be good to not have unused variables like b here, and a, b in the example below. For this one, replacing it with _ would be ok, for the one below, maybe print them as well as the entire tuple?

c @ (_, b) if b < 2 => println!("Second arm {:?}", c),
_ => {}
}
~~~~

Here is an example of a subpattern as-pattern:

> ***Note:*** The following code makes use of Option\<T\> which is explained
> in section 17 and the [Error-handling and Conditions][conditions] tutorial.

~~~
let x: Option<(u8, i16)> = Some((10u8, 5i16));
match x {
Some(tuple @ (a, b)) => { println!("{:?}", tuple) },
None => { println!("Nothing to see here.") }
}
~~~

This will print `(10u8, 5i16)`.

## Loops

`while` denotes a loop that iterates as long as its given condition
Expand Down Expand Up @@ -3239,3 +3278,4 @@ more out of date than this document.

[wiki]: https://github.com/mozilla/rust/wiki/Docs
[wiki-packages]: https://github.com/mozilla/rust/wiki/Doc-packages,-editors,-and-other-tools
[as-pattern]: https://en.wikibooks.org/wiki/Haskell/Pattern_matching#As-patterns