In Dart 3, how does a switch expression differ from a switch statement, and where may a switch expression appear?

## Two forms of the same pattern switch Since **Dart 3.0**, every `case` in Dart holds a **pattern**, and the language offers two shapes of `switch` built on the same matching machinery: - a **switch statement** — control flow: each matching case runs a list of statements and nothing is produced; - a **switch expression** — a value: each matching case evaluates one expression, and the whole `switch (...) { ... }` evaluates to that result. Both match cases top to bottom, both accept any pattern kind, both allow a `when` guard after a pattern, and in both the variables a pattern binds are in scope only inside that case's body. What differs is the syntax, where the construct may be written, and how strictly the compiler demands that every value be covered. ## Syntax side by side | Aspect | Switch statement | Switch expression | |---|---|---| | Case keyword | `case pattern:` | no `case` keyword | | Body | one or more statements | exactly one expression, after `=>` | | Separator between cases | none (new `case` line) | a comma; a trailing comma is allowed | | Default | `default:` or `case _:` | only `_ =>` | | Empty case | allowed; falls through to the next case | not allowed; every case needs a body | | Result | none | the value of the matching case | A few consequences of that table: - Because a case body must be an **expression**, you cannot put a sequence of statements inside a switch expression case. If a branch needs several steps, call a function from it or use a statement instead. - `throw` is an expression in Dart, so `_ => throw FormatException('Invalid')` is a legal last case. - To make several patterns share one body in an expression, use a **logical-or pattern** (`Plan.pro || Plan.team => ...`) rather than stacked empty cases. - In a Dart 3 switch **statement**, a non-empty case no longer falls through, so `break` at its end is redundant; that is statement behaviour, not something the expression form has at all. ## Where a switch expression can appear A switch expression may be written wherever Dart accepts an expression: - the right-hand side of a declaration or assignment: `final price = switch (plan) { ... };` - a `return` or an arrow body: `String label(Plan p) => switch (p) { ... };` - a function or constructor argument, including a Flutter widget argument such as `Text(switch (page) { ... })`; - inside a collection literal, string interpolation or another expression. The one exception is the **start of an expression statement**. A line that begins with `switch (` is parsed as a switch statement, so a bare `switch (x) { ... };` used only for its value is not a switch expression. If you want side effects and no value, write the statement form. ## Exhaustiveness: the rule that really differs 1. A **switch expression must always be exhaustive**: every value of the scrutinee's static type must match some case. If one could slip through, the analyzer reports `non_exhaustive_switch_expression`, a compile-time error. There is no "produce nothing" outcome for an expression. 2. A **switch statement** is checked the same way **only** when it switches over an *exhaustive type* — `bool`, an enum, a `sealed` class, or a nullable version of one of those. Then a missing case is the error `non_exhaustive_switch_statement`. 3. A switch statement over any other type — `int`, `String`, an ordinary class — may leave values unmatched; they simply run no case. 4. A `_` case (or `default` in a statement) matches everything and therefore makes any switch exhaustive — at the cost of hiding future omissions. ## The result type A switch expression has a static type inferred from its case bodies (their common upper bound, guided by the context type, such as the declared type of the variable it initialises). If one case returns `int` and another `double`, the result is `num`; if the context is `String`, every case must produce a `String`. ```dart enum Plan { free, pro, team } int monthlyPriceCents(Plan plan) => switch (plan) { Plan.free => 0, Plan.pro => 900, Plan.team => 2400, }; void logPlan(Plan plan) { switch (plan) { case Plan.free: print('free tier'); case Plan.pro || Plan.team: print('paid tier'); } } ``` ## Choosing between them - Reach for the **expression** when every branch computes a value of the same kind — a price, a label, a widget, an icon. - Reach for the **statement** when branches perform different side effects, need several statements, or should deliberately do nothing for unmatched values of an open type. - Prefer letting the compiler prove coverage over adding `_` by reflex: on enums and sealed types the explicit list of cases is what turns a new value into a compile error rather than a silent default. Switch expressions need a language version of at least 3.0; since Dart 3.10, dot shorthands also let cases on an enum be written as `.pro` when the type is known from the scrutinee.