Invalid type passed!
Received:
{type}
Expected one of:
{asideVariants.join(", ")}
: <>
{title &&
{title}
}
{children}
}
;
};
Tolk supports a `match` expression for pattern matching.
It is a powerful construct that applies both to types and expressions.
## `match` for union types
Pattern matching for unions is a key to [message handling](/languages/tolk/features/message-handling).
```tolk theme={null}
type IncomingMessage =
| CounterIncBy
| CounterReset
// ...
// ... after parsing a message
match (msg) {
CounterIncBy => {
newCounter = curCounter + msg.byValue
}
CounterReset => {
newCounter = 0
}
// ...
}
```
Although it's a general mechanism compatible with any union type:
```tolk theme={null}
fun processValue(value: int | slice) {
match (value) {
int => {
value * 2
}
slice => {
value.loadUint(8)
}
}
}
```
## `match` for a union must be exhaustive
In other words, all alternatives must be covered.
```tolk theme={null}
fun errDemo(v: int | slice | Point) {
match (v) {
slice => { v.loadAddress() }
int => { v * 2 }
// error: missing `Point`
}
}
```
Note that `else` is not allowed for unions but is permitted for a [lazy match](/languages/tolk/features/lazy-loading#lazy-matching).
## Syntax details
* After `=>` there is
* either a block: `A => { ... }`
* or an expression: `A => 123`
* or `A => return SOME_EXPR`
* or `A => throw ERR_CODE`
* A comma
* optional after a block: `A => {} B => {}`
* required otherwise: `A => 1, B => 2`
* May be used as a match expression: `return match (v) { ... }`
* Variable declarations are allowed inside: `match (val v = ...)`
## Using `match` as an expression
Using `match` in expression position allows:
* `var smth = match (v) { ... }`
* `return match (v) { ... }`
* and similar
```tolk theme={null}
type Pair2 = (int, int)
type Pair3 = (int, int, int)
fun getLast(tensor: Pair2 | Pair3) {
return match (tensor) {
Pair2 => tensor.1,
Pair3 => tensor.2,
}
}
```
## Declaring variables inside `match`
```tolk theme={null}
fun getPair2Or3(): Pair2 | Pair3 {
// ...
}
fun demo() {
match (val v = getPair2Or3()) {
Pair2 => return v.0 + v.1,
Pair3 => throw v.0 + v.1 + v.2,
}
}
```
## `match` for expressions (not for types)
`match` can be used with constant expressions, similar to `switch`:
```tolk theme={null}
val nextValue = match (curValue) {
1 => 0,
0 => 1,
else => -1
};
```
Rules:
* only constant expressions may appear before `=>`
* `else` is required for match expressions and optional for statements
```tolk theme={null}
// statement form
match (curValue) {
1 => { nextValue = 0 }
0 => { nextValue = 1 }
-1 => throw NEGATIVE_NOT_ALLOWED
}
// expression form, `else` required
val nextValue = match (curValue) {
// ...
else => 1 + 2
}
```
## `match` for enums
Pattern matching on [enums](/languages/tolk/types/enums) requires coverage of all cases (*exhaustive*):
```tolk theme={null}
match (someColor) {
Color.Red => {}
Color.Green => {}
// error: Color.Blue is missing
}
```
Alternatively, use `else` to handle remaining values:
```tolk theme={null}
match (someColor) {
Color.Red => {}
else => {}
}
```