1.9 KiB
Patterns and Matching
Patterns are a special syntax in Rust for matching against the structure of types, both complex and simple.
Using patterns in conjunction with match expressions and other constructs give you more control over a program's flow.
A pattern consists of some combination of the following:
- Literals
- Destructured arrays, enums, structs, or tuples
- Variables
- Wildcards
- Placeholders
Some examples include
x,(a, 3)andSome(Color::Red).
In the contexts in which patterns are valid, these components describe the shape of data.
Our program then matches values against the patterns to determine whether it has the correct shape of data to continue running a particular piece of code.
In order to use a pattern, we compare it to some value.
If the pattern matches the value, we use the value parts in our code.
Recall the match expression that used patterns, such as the coin-sorting machine example.
If the value fits the shape of the pattern, we can use the named pieces.
If it doesn't, the code associated with the pattern won't run.
This chapter is intended to be a reference on all things related to patterns.
We will cover:
- Valid places to use patterns Section Link Here
- Difference between refutable and irrefutable patterns Section Link Here
- Different kinds of pattern syntax Section Link Here By the end you will know how to use patterns to express many concepts in a clear way.
Summary
Patterns are very useful in distinguishing between different kinds of data.
When used in match expressions, Rust ensures your patterns cover every possible value, or your program will not compile.
Patterns in let statements and function parameters make those constructs more useful, enabling the destructuring of values into smaller parts at the same time as assigning to variables.
Then we can create simple or complex patterns to suit our needs.