Implementing a generic function with a conditional return type

by

The underlying issue is that TypeScript’s compiler does not narrow the type of a generic type variable via control flow analysis. When you check (typeof maybeNumber === "number"), the compiler can narrow the value maybeNumber to number, but it does not narrow the type parameter T to number. And therefore it cannot verify that it’s safe to assign a number value to the return type T extends number ? number : string. The compiler would have to perform some analysis it currently does not do, such as “okay, if typeof maybeNumber === "number", and we inferred T from the type of maybeNumber alone, then inside this block we can narrow T to number, and therefore we should return a value of type number extends number ? number : string, a.k.a., number“. But this doesn’t happen.

This is quite a pain point with generic functions with conditional return types. The canonical open GitHub issue about this is probably microsoft/TypeScript#33912, but there are a bunch of other GitHub issues out there where this is the main problem.

So that’s the answer to “why doesn’t this work”?

If you’re not interested in refactoring to get this to work, you can ignore the rest, but it might still be instructive to know what to do in this situation instead of waiting for the language to change.

The most straightforward workaround here that maintains your call signature is to make your function a single signature overload where the implementation signature is not generic. This essentially loosens the type safety guarantees inside the implementation:

type MyConditional<T> = T extends number ? number : string;
type Unknown = string | number | boolean | {} | null | undefined;

function test<T>(maybeNumber: T): MyConditional<T>;
function test(maybeNumber: Unknown): MyConditional<Unknown> {
  if (typeof maybeNumber === 'number') {
    const ret: MyConditional<typeof maybeNumber> = maybeNumber;
    return ret;
  }
  const ret: MyConditional<typeof maybeNumber> = "Not a number";
  return ret;
}

Here I’ve gone about as far as I can go to try to guarantee type safety, by using a temporary ret variable annotated as MyConditional<typeof maybeNumber> which uses the control-flow-analysis-narrowed type of maybeNumber. This will at least complain if you switch around the check (turn === into !== to verify). But usually I just do something simpler like this and let the chips fall where they may:

function test2<T>(maybeNumber: T): MyConditional<T>;
function test2(maybeNumber: any): string | number {
  if (typeof maybeNumber === 'number') {
    return maybeNumber;
  }
  return "Not a number";
}

Okay, hope that helps; good luck!

Playground link to code

More Related Contents:

  1. Create a global variable in TypeScript
  2. How to use jQuery with TypeScript
  3. Way to tell TypeScript compiler Array.prototype.filter removes certain types from an array?
  4. Type definition in object literal in TypeScript
  5. Difference between Variance, Covariance, Contravariance and Bivariance in TypeScript
  6. Angular 2: Convert Observable to Promise
  7. Angular2 canActivate() calling async function
  8. Purpose of declare keyword in TypeScript
  9. Is it possible to restrict number to a certain range
  10. ESLint – Configuring “no-unused-vars” for TypeScript
  11. Keyof inferring string | number when key is only a string
  12. Object destructuring with property names that are not valid variable names
  13. Function property vs method
  14. How to declare a type as nullable in TypeScript?
  15. How to use Object.values with typescript?
  16. is there a way to get all required properties of a typescript object
  17. Typescript: ReturnType of overloaded function
  18. What TypeScript version is Visual Studio Code using? How to update it?
  19. Why does TypeScript track mutation of function static properties?
  20. Array VS Type[] in Typescript
  21. TypeScript filter out nulls from an array
  22. typescript: validate excess keys on value, returned from function
  23. How to use array.map with tuples in typescript?
  24. Typescript: Omit a property from all interfaces in a union, but keep the union structure
  25. Declaring abstract method in TypeScript
  26. how to remove properties via mapped type in TypeScript
  27. TypeScript empty object for a typed variable
  28. What does a TypeScript index signature actually mean?
  29. Why does a Typescript type conditional on `T extends undefined`, with T instantiated with `boolean`, resolve T to `never`?
  30. Is it possible to export * as foo in typescript

Leave a Comment