Reword f5fc090

- Titles are title-cased
- Preserve continuity by emphasizing the features right after previous mentions.
- Preserve continuity by using the same examples on this page.
- Also demonstrate binding name shared with different patterns in the fall-through example.
- Avoid using overly generic examples like `A`, `B`, `1` and `2`. Though here the immediacy from the specific examples isn't increased _that_ much. But still, helps remembering.
- Avoid introducing one-off terms.

Unfortunately more verbose than the previous version, but it might be needed.

Author: chenglou

pages/docs/manual/latest/pattern-matching-destructuring.mdx

@@ -299,7 +299,7 @@ if (person1.TAG) {
 
 **Note** how we've:
 - drilled deep down into the value concisely
-- using a nested pattern check `"Mary" | "Joe"` and `Vacations | Sabbatical`
+- using a **nested pattern check** `"Mary" | "Joe"` and `Vacations | Sabbatical`
 - while extracting the `daysLeft` number from the latter case
 - and assigned the greeting to the binding `message`.
 
@@ -330,6 +330,39 @@ isBig \ myAnimal | Dog | Cat | Bird
 true             |  1  |  2  |  3
 false            |  4  |  4  |  5
 
+### Fall-Through Patterns
+
+The nested pattern check, demonstrated in the earlier `person` example, also works at the top level of a `switch`:
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res prelude
+let myStatus = Vacations(10)
+
+switch myStatus {
+| Vacations(days)
+| Sabbatical(days) => Js.log(`Come back in ${Js.Int.toString(days)} days!`)
+| Sick
+| Present => Js.log("Hey! How are you?")
+}
+```
+```js
+var myStatus = {
+  TAG: /* Vacations */0,
+  _0: 10
+};
+
+if (typeof myStatus === "number") {
+  console.log("Hey! How are you?");
+} else {
+  console.log("Come back in " + (10).toString() + " days!");
+}
+```
+
+</CodeTab>
+
+Having multiple cases fall into the same handling can clean up certain types of logic.
+
 ### Ignore Part of a Value
 
 If you have a value like `Teacher(payload)` where you just want to pattern match on the `Teacher` part and ignore the `payload` completely, you can use the `_` wildcard like this:
@@ -352,7 +385,47 @@ if (person1.TAG) {
 
 </CodeTab>
 
-`_` also works at the top level of the pattern like `| _ => ...` if you want to execute catch-all condition.
+`_` also works at the top level of the `switch`, serving as a catch-all condition:
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res example
+switch myStatus {
+| Vacations(_) => Js.log("Have fun!")
+| _ => Js.log("Ok.")
+}
+```
+```js
+if (typeof myStatus === "number" || myStatus.TAG) {
+  console.log("Ok.");
+} else {
+  console.log("Have fun!");
+}
+```
+
+</CodeTab>
+
+**Do not** abuse a top-level catch-all condition. Instead, prefer writing out all the cases:
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res example
+switch myStatus {
+| Vacations(_) => Js.log("Have fun!")
+| Sabbatical(_) | Sick | Present => Js.log("Ok.")
+}
+```
+```js
+if (typeof myStatus === "number" || myStatus.TAG) {
+  console.log("Ok.");
+} else {
+  console.log("Have fun!");
+}
+```
+
+</CodeTab>
+
+Slightly more verbose, but a one-time writing effort. This helps when you add a new variant case e.g. `Quarantined` to the `status` type and need to update the places that pattern match on it. A top-level wildcard here would have accidentally and silently continued working, potentially causing bugs.
 
 ### When Clause
 
@@ -572,42 +645,6 @@ if (myNullableValue !== undefined) {
 
 If you don't handle the `None` case, the compiler warns. No more `undefined` bugs in your code!
 
-### Match multiple cases to one expression
-
-Now, sometimes you may want to pattern-match on large but finite sets of possibilities where many possibilities map to the same expression. In these cases, wildcards can seem tempting because they reduce code duplication, but there's another option, often termed disjunctive patterns, that allow you to map multiple patterns to a single expression. That is, you can replace:
-
-```res example
-type t = A | B | C | D | E
-let v = C
-switch v {
-| A => 1
-| _ => 2
-}
-```
-
-with:
-
-```res example
-type t = A | B | C | D | E
-let v = C
-switch v {
-| A => 1
-| B | C | D | E => 2
-}
-```
-
-This still requires a bit more work than a wildcard, but it has the advantage of ensuring the compiler can enforce exhaustiveness, unlike a wildcard based solution. Additionally, unlike wildcards, you can easily refactor your code to have multiple pattern sets, like so:
-
-```res example
-type t = A | B | C | D | E
-let v = C
-switch v {
-| A => 1
-| B | C => 2
-| D | E => 3
-}
-```
-
 ## Conclusion & Tips & Tricks
 
 Hopefully you can see how pattern matching is a game changer for writing correct code, through the concise destructuring syntax, the proper conditions handling of `switch`, and the static exhaustiveness check.