TypeScript: Type Guard optimization guide as Expected with Conditional Types
I'm confused about I'm sure I'm missing something obvious here, but I've been struggling with this for a few days now and could really use some help... I'm working on a TypeScript project (version 4.5.2) where I need to create a type guard that distinguishes between different types based on a property value. I have a union type of two interfaces, `Cat` and `Dog`, and I want to implement a function that checks the `type` property to narrow down the type accordingly. Here's the code I've written so far: ```typescript interface Cat { type: 'cat'; meow: () => string; } interface Dog { type: 'dog'; bark: () => string; } type Pet = Cat | Dog; function isCat(pet: Pet): pet is Cat { return pet.type === 'cat'; } const pets: Pet[] = [ { type: 'cat', meow: () => 'Meow!' }, { type: 'dog', bark: () => 'Woof!' }, ]; const cat = pets.find(isCat); console.log(cat.meow()); // behavior: Property 'meow' does not exist on type 'Pet'. ``` I expected that once the `isCat` guard confirmed the type, TypeScript would allow access to the `meow` method. However, I'm getting an behavior stating that the `meow` property does not exist on type `Pet`. I tried changing the return type of the `isCat` function to just `boolean`, but that led to the same scenario. I also checked for TypeScript's strict settings in my `tsconfig.json`, but everything looks fine. I feel like I must be missing something fundamental about how TypeScript handles type guards in conjunction with the `find` method. Any insights on what I might be doing wrong or how I could resolve this scenario would be greatly appreciated! What's the best practice here? For context: I'm using Typescript on macOS. What's the best practice here? I'm working in a CentOS environment. Am I missing something obvious?