Match — exhaustive pattern matching

Effect v3.12.0

the _tag discriminant was introduced in Data ↗

The usual way to branch on a tagged union in TypeScript is a switch on the tag. With no exhaustiveness guard, it works today and lies tomorrow. Add a Triangle variant later, forget a case, and this still compiles. The return type just quietly grows an undefined and the missing branch ships. You can defend it with a never assertion in a default case, if you remember to write one every time.

Match.type builds a matcher over the union instead. Each Match.tag handles one variant and infers its fields for you, and Match.exhaustive seals the set. It reads as a table of cases, not a fall-through, and the type is the same function you had before, Shape to number.

Now the payoff. Add the Triangle variant to the union and leave its case out, and Match.exhaustive stops compiling, right at the match site, naming the tag you forgot. The case you would have missed is a type error now, not a production incident, and the matcher stays exhaustive by the compiler's insistence.

// Plain TypeScript: switch on a discriminant. With no exhaustiveness guard, add a
// "Triangle" variant later and this still compiles — the return type just quietly
// widens to include undefined, and the missing case ships.
type Shape =
  | { _tag: "Circle"; radius: number }
  | { _tag: "Square"; side: number };

const area = (shape: Shape) => {
  switch (shape._tag) {
    case "Circle":
      return Math.PI * shape.radius ** 2;
    case "Square":
      return shape.side ** 2;
  }
};
//    ^? (shape: Shape) => number

console.log(area({ _tag: "Square", side: 3 })); // 9

❚❚ beat