Narrowing discriminated unions with user-defined type guards #11787

Activity

1. aluanhaddad commented on Oct 22, 2016

   

   Aluan Haddad (aluanhaddad)

   on Oct 22, 2016

   Contributor

   More actions

   What is narrowsInUnion in your example? I cannot find it.
2. masaeedu commented on Oct 24, 2016

   

   Asad Saeeduddin (masaeedu)

   on Oct 24, 2016

   Contributor

   More actions

   Aluan Haddad (@aluanhaddad) I think that's just a typo for narrows.

   👍React with 👍1Reacted by Tim Ruffles
3. masaeedu commented on Oct 25, 2016

   

   Asad Saeeduddin (masaeedu)

   on Oct 25, 2016

   Last edited by masaeedu

   Contributor

   More actions

   Tim Ruffles (@timruffles) It doesn't seem like what you're proposing generalizes well. Your narrows invocation is oblivious to the type of cheeseSample, you're just passing in an arbitrary expression of type string that you establish for the remainder of the function to be a particular string literal.

   What you want to do can be accomplished with the existing type system, it is just somewhat awkward:

   type Cheese = {
       type: 'brie';
       brieOnly: true,
   } |
   {
       type: 'cheddar';
       cheddarOnly: true,
   };
   
   function narrows<Wide, Narrow extends Wide>(w: Wide, f: (w: Wide) => Narrow): w is Narrow {
       return f(w) !== undefined;
   }
   
   function doSomethingWithCheese(cheeseSample: Cheese) {
       if (cheeseSample.type === 'cheddar') {
           cheeseSample.cheddarOnly;
       }
   
       if (narrows(cheeseSample, c => c.type === 'cheddar' ? c : undefined)) {
           const t: 'cheddar' = cheeseSample.type;
           cheeseSample.cheddarOnly;
       }
   }

   Right now I'm relying on type inference to make this work, but the fact that you have to use undefined and return the actual instance instead of a boolean is awkward. Possibly with some more indirection for type inference and narrowing in the language, this could be expressed less hackishly.

   👍React with 👍1Reacted by Sean Vieira
4. Ryan Cavanaugh (RyanCavanaugh)

   added

   Needs InvestigationThis issue needs a team member to investigate its status.This issue needs a team member to investigate its status.

   on May 24, 2017
5. seansfkelley commented on Aug 31, 2018

   

   Sean Kelley (seansfkelley)

   on Aug 31, 2018

   More actions

   This is still an issue in 3.x. I had a slightly simpler variant that didn't have a type-parameterized type guard, but I think it's the same basic issue:

   interface Foo {
       type: "foo";
       foo: string;
   } 
   
   interface Bar {
       type: "bar";
       bar: string;
   }
   
   type FooBar = Foo | Bar;
   
   function isFooType(t: "foo" | "bar"): t is "foo" {
       return true;
   }
   
   const f: FooBar = null as any;
   
   if (f.type === "foo") {
       f.foo; // works
   }
   
   if (isFooType(f.type)) {
       f.foo; // breaks
   }

   playground link

   This is a bummer, cause it means that a user-defined type guard deep in the type hierarchy may get bubbled up with "wrapper" type guards for containing types in order to discriminate them:

   function isFoo(foobar: Foo | Bar): foobar is Foo {
       return isFooType(foobar.type);
   }

   👍React with 👍2Reacted by sladavich-iqvia and Christian Radich
6. timruffles commented on Nov 29, 2018

   

   Tim Ruffles (timruffles)

   on Nov 29, 2018

   Author

   More actions

   Asad Saeeduddin (@masaeedu) the narrows call is not attempting to narrow cheeseSample, it's narrowing its type field. I'm suggesting that the information we gain from that narrowing is used to infer the type of cheeseSample.

   If you re-read my example you'll see it's the same narrowing & inference logic as is used in the primitive example .type === 'cheese I gave above it, just with user-defined type guards rather than ===.
7. cnradich commented on Jun 3, 2019

   

   Christian Radich (cnradich)

   on Jun 3, 2019

   Last edited by cnradich

   More actions

   Also running into this issue as of 3.6.0-dev.20190603. Another simple example:

   interface Square {
       kind: "square";
       size: number;
   }
   
   interface Rectangle {
       kind: "rectangle";
       width: number;
       height: number;
   }
   
   type Shape = Square | Rectangle;

   Using a basic Shape discriminated union example.

   Demonstrates expected discriminated union type inference:

   const shape1: Shape = JSON.parse('{ "kind": "square", "size" : 10 }');
   
   console.log(shape1.kind); // compiles, as expected
   console.log(shape1.size); // compiler error, as expected
   if (shape1.kind === "square") {
       console.log(shape1.size); // compiles, as expected
   }

   Demonstrates incorrect discriminated union type inference using type guard:

   const isShape = (value: any): value is Shape => typeof value === 'object' && value !== null && typeof value.kind === 'string' /* && etc... */;
   
   const shape2: unknown = JSON.parse('{ "kind": "square", "size" : 10 }');
   
   if (isShape(shape2)) {
       console.log(shape2.kind); // compiles, as expected
       console.log(shape2.size); // compiler error, as expected
       if (shape2.kind === "square") {
           console.log(shape2.size); // compiler error, NOT expected
       }
   }

   playground
8. Ryan Cavanaugh (RyanCavanaugh)

   added

   DuplicateAn existing issue was already createdAn existing issue was already created

   and removed

   Needs InvestigationThis issue needs a team member to investigate its status.This issue needs a team member to investigate its status.

   on Aug 22, 2019
9. RyanCavanaugh commented on Aug 22, 2019

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Aug 22, 2019

   Member

   More actions

   The narrows definition is not something that can narrow the outer type, as discussed above

   Alternately, duplicate #30557
10. Ryan Cavanaugh (RyanCavanaugh)

    closed this as completedon Aug 22, 2019
11. microsoft

    locked as resolved and limited conversation to collaborators on Oct 21, 2025