When working with types that have multiple variants, like enumerations, each variant often needs to be handled separately. Exhaustiveness checking ensures that all variants or cases are explicitly covered, typically within conditional statements like `switch` in JavaScript or TypeScript, `match` in Python or Rust, or `if-else`. This is especially useful when adding new variants, as it prompts updates to all related code. In dynamically typed languages, where type information is resolved at runtime, exhaustiveness checking can only happen as the code runs, handling cases as they occur and throwing errors when unexpected cases appear. Since there’s no compile-time check, dynamic exhaustiveness checking relies on runtime errors to signal unhandled cases. While dynamic exhaustiveness checking aids in maintaining code when new variants are added, it also increases the risk of runtime errors and lacks early detection. By contrast, statically typed languages, which include compile-time type information, allow type checkers or compilers to verify exhaustiveness before runtime. This enables early error detection, improving efficiency and reducing the chance of runtime issues. Static exhaustiveness checking leverages the information provided by static typing, defining the possible types and values a variable can take. This allows the type checker or compiler to anticipate all potential cases ensuring comprehensive case handling and minimizing errors.