How does pattern matching work in Scala? Provide an example.

Pattern matching is a powerful feature in Scala that allows developers to destructure complex data structures and match them against patterns, enabling concise and expressive code. Pattern matching in Scala works by comparing the structure of a given expression against a set of patterns and executing the corresponding code block based on the matched pattern. It is similar to the switch statement in other languages but provides much more flexibility and expressive power.

Here's how pattern matching works in Scala:

1. Syntax:
The syntax for pattern matching in Scala is as follows:

```
javascript`expression match {
case pattern1 => code1
case pattern2 => code2
...
case patternN => codeN
}`
```
The `expression` is evaluated, and its structure is compared against each `pattern` until a match is found. Once a match is found, the corresponding `code` block is executed.

2. Matching Patterns:
Patterns can take various forms, including:
* Literal Values: Matching against specific constant values, such as integers, strings, or boolean values.
* Wildcards: Using the underscore (`_`) to match any value, disregarding its actual content.
* Variables: Binding values to variables, allowing access to specific parts of the matched expression.
* Case Classes: Pattern matching is commonly used with case classes. The pattern can match the case class's fields and extract their values.
* Tuples: Matching against tuples by deconstructing them into their individual elements.
* Lists and Sequences: Pattern matching can be used to match the structure of lists or sequences, allowing for recursive patterns.
* Option and Either: Pattern matching is often used with `Option` and `Either` types to handle possible values or error cases.
3. Exhaustiveness and Wildcard:
Scala encourages exhaustiveness, meaning that all possible cases should be covered in the pattern matching code. To ensure this, it is common to include a wildcard pattern (`_`) as the last case to handle any unmatched values.
4. Pattern Guards:
Pattern guards can be added to pattern cases using the `if` keyword. Guards allow for additional conditions to be checked before executing the code block associated with the matched pattern.

Here's an example that demonstrates the usage of pattern matching in Scala:

```
scala`def matchNumber(num: Int): String = num match {
case 0 => "Zero"
case 1 => "One"
case 2 => "Two"
case _ => "Other"
}

val result = matchNumber(2)
println(result) // Output: "Two"`
```
In this example, the `matchNumber` function takes an integer `num` and matches it against different cases. If `num` is 0, it returns "Zero". If `num` is 1, it returns "One". If `num` is 2, it returns "Two". If none of the previous cases match, it falls back to the wildcard case and returns "Other". The `matchNumber(2)` call matches against the case `2`, so the output will be "Two".

Pattern matching in Scala provides a concise and readable way to handle complex data structures and make decisions based on their structure. It is a versatile tool that enables developers to write expressive and type-safe code, especially when working with algebraic data types, recursive structures, or complex APIs.