Why does a Typescript type conditional on `T extends undefined`, with T instantiated with `boolean`, resolve T to `never`?

by

As written,

type OptionalArgBroken<Arg> = Arg extends undefined ?
    () => void :
    (arg: Arg) => void;

is a distributive conditional type because the type being checked, Arg, is a naked generic type parameter.

“Distributive” means that if the Arg passed in is a union, then the type will be evaluated for each member of the union separately and then united back together (so the operation is distributed across the union). In other words, OptionalArgBroken<A | B | C> will be the same as OptionalArgBroken<A> | OptionalArgBroken<B> | OptionalArgBroken<C>.

This is likely not your intent, as evidenced by the fact that you are happy with the results when you wrap your check in [] (which makes the checked type no longer “naked” by “clothing” it).

Furthermore, the TypeScript compiler treats the boolean type as a shorthand for the union of true and false, the so-called boolean literal types:

type Bool = true | false;
// type Bool = boolean

If you hover over Bool in your IDE with IntelliSense, you will see that Bool above is displayed as boolean.

This might be surprising if you think of boolean as a single type and not a union of two other types. And one place this shows up is when you pass boolean to a distributive conditional type: OptionalArgBroken<boolean> is OptionalArgBroken<true | false> which is OptionalArgBroken<true> | OptionalArgBroken<false> which is

type OABBool = OptionalArgBroken<boolean>;
// type OABBool = ((arg: false) => void) | ((arg: true) => void)

You passed in what you thought was a single type and got a union of function types out. Oops. (See microsoft/TypeScript#37279)

And a union of function types can only be safely called with an intersection of their parameters. Read the TS3.3 release notes on support for calling a union of functions for information about why this is.

But that means a value of type OptionalArgBroken<boolean> can only be called with an argument of type true & false, which is reduced to never (see microsoft/TypeScript#31838) because there is no value which is both true and false.

And therefore, when you try to call haveArgBroken, it expects the parameter passed in to be of type never:

const haveArgBroken: OptionalArgBroken<boolean> = function (b: boolean) { };
// haveArgBroken(arg: never): void

And true is not of type never, so it fails:

haveArgBroken(true); // Type error

And that’s why your original code did not work.

Note that the same thing happens with

type ExtendsUndefined<T> = T extends undefined ? 'yes' : 'no'

but it is benign because ExtendsUndefined<boolean> becomes ExtendsUndefined<true> | ExtendsUndefined<false> which is 'no' | 'no' which is reduced to just 'no'. It happens to be what you want, but only because there’s no way to distinguish the 'no' that came from true with the one that came from false.

Playground link to code

More Related Contents:

  1. TypeScript conditional types – filter out readonly properties / pick only required properties
  2. Typescript: Type of a property dependent on another property within the same object
  3. How do I type an object with known and unknown keys in TypeScript
  4. What is “not assignable to parameter of type never” error in TypeScript?
  5. When I refresh my website I get a 404. This is with Angular2 and firebase
  6. Expected 3 type arguments but got 1 but it should infer 2 types
  7. Import class in definition file (*d.ts)
  8. TypeScript union of string and string literals
  9. Typescript return type depending on parameter
  10. Mapped Types: removing optional modifier
  11. Why can I avoid excess property check in typescript just by passing a reference to an object to a function rather than the object in its literal form?
  12. TypeScript: Accept all Object keys that map to a specific type
  13. Typescript interface default values
  14. How to configure custom global interfaces (.d.ts files) for TypeScript?
  15. How to selectively assign from one Partial to another in typescript
  16. Experimental decorators warning in TypeScript compilation
  17. A TypeScript GUID class? [closed]
  18. How to define an opaque type in TypeScript?
  19. What is the Record type?
  20. Mapping tuple-typed value to different tuple-typed value without casts
  21. TypeScript function return type based on input parameter
  22. What does “homomorphic mapped type” mean?
  23. What does “all legal JavaScript is legal TypeScript” mean?
  24. Empty interface allow any object?
  25. RxJs get value from observable
  26. How to prevent unintended type compatibility in TypeScript
  27. What means “ambient” in TypeScript
  28. Extending global types (e.g. “Window”) inside a typescript module
  29. TypeScript keyof index type is too wide
  30. get dictionary/object keys as tuple in typescript

Leave a Comment