从枚举参数推断 Typescript 函数返回类型

Question

I want to create a loading service that returns properly typed data for IDs defined in an enum. What I did looks like this:

enum IdentifierEnum {
  ID1 = 'ID1', 
  ID2 = 'ID2'
}

interface DataType {
  [IdentifierEnum.ID1]: number,
  [IdentifierEnum.ID2]: string
}

class LoadingService {
  loadData<K extends IdentifierEnum>(key: K): DataType[K] {
    // ...
  }
}

Using this approch, the types are correctly inferred when using the loading service:

const loadingService: LoadingService = new LoadingService();
const data1 = loadingService.loadData(IdentifierEnum.ID1); // type: number
const data2 = loadingService.loadData(IdentifierEnum.ID2); // type: string

The only issue I am facing is, that inside the implementation of loadData , the type parameter K is only inferred as IdentifierEnum . Therefor the following won't work:

class LoadingService {
  loadData<K extends IdentifierEnum>(key: K): DataType[K] {
    if (key === IdentifierEnum.ID1) {
      return 1; // Error: Type '1' is not assignable to type 'DataType[K]'.
    }
    // ..
  }
}

It absolutely makes sense to me that this is the case. Still, I would love to have a completely typesafe solution for this.

I already tried overloading the function, but that leaves me with the problem that still I have to provide an implementing signature, which is either too specific (like the above) or too general, which again removes the typesafety I desire. The same goes for casting the return value. What I need is basically a way to really type-check the input value instead of just checking its value.

Is there a possibility to do this? Or maybe a whole different way to solve this problem that provides typesafety for both the usage and the implementation of the loading service?

Side note

The implementation may seem overly complex for this simple purpose, but the reason for this is that there is a generic base class for the loading service that looks like this:

// Base class
abstract class AbstractLoadingService<E extends string | number | symbol, T extends {[K in E]: any}> {
  abstract loadData<K extends E>(key: K): T[K];
}

// Implementation
class LoadingService extends AbstractLoadingService<IdentifierEnum, DataType> {
  loadData<K extends IdentifierEnum>(key: K): DataType[K] {
    // ...
  }
}

Answer 1

This is a known pain point in TypeScript, see microsoft/TypeScript#13995 and microsoft/TypeScript#24085 . The issue is that control-flow based type analysis does not apply to generic type parameters.

If key were declared to be of type IdentifierEnum , then the check if (key === IdentifierEnum.ID1) {...} would narrow the type of key inside the {...} block to be Identifier.ID1 :

const k: IdentifierEnum = key;
if (k === IdentifierEnum.ID1) {
  k; // const k: IdentifierEnum.ID1
} else {
  k; // const k: IdentifierEnum.ID2
}
 

That's control flow analysis. Now this doesn't happen when key is of generic type K , but even if it did, it wouldn't help you:

if (k === IdentifierEnum.ID1) {
  return 1; // ERROR! 
}

That's because, as of TypeScript 3.8 anyway, even if a value of type K is narrowed, the type K itself is not . The compiler never says "if key is IdentifierEnum.ID1 , then K is IdentifierEnum.ID1 ." So you can't use this sort of control-flow based implementation if you want the compiler to verify type safety for you.

It's possible that future versions of TypeScript will make this better in some way, but it's tricky. In general, just because a value x of type X can be narrowed to type Y , it doesn't mean the type X itself can be narrowed. This is obvious if you have multiple values of type X sitting around. But anyway, for now, this is something to work around.

---

You've already explored and been unhappy with the less type-safe ways of doing this: type assertions and overload signatures, so I will dispense with writing out how you would implement that.

---

The only way to do something relatively type safe here is to give up on control flow analysis, and instead use an indexing operation. The compiler is smart enough to realize that if you have a value t of type T and a value k of type K extends keyof T , that the value t[k] will be of type T[K] . In your case, T is DataType . So you need a value of that type to index into:

class LoadingService {
  loadData<K extends IdentifierEnum>(key: K): DataType[K] {
    return {
      get [IdentifierEnum.ID1]() { return 1; },
      get [IdentifierEnum.ID2]() { return "" }
    }[key]; // okay
  }
}

The above type checks. Note that I implemented the properties as getters . You don't have to do this; you could have just written:

return {
  [IdentifierEnum.ID1]: 1,
  [IdentifierEnum.ID2]: ""
}[key];

but the getter version allows you to do more arbitrary calculations and know that only the one corresponding to key will get evaluated.

---

Playground link to code