打字稿：如何从受查找类型泛型返回联合约束的泛型函数返回正确的类型

Question

So let's say we have following function implementation:

type Action = 'GREET' |'ASK'

function getUnion<T extends Action>(action: T) {
  switch (action) {
  case 'GREET':
    return {hello: 'Guten Tag!'} as const
  case 'ASK':
    return {time: 'Wie spat is es?'} as const
  default:
    return 'WUT?'
  }
}

Return type of this function is following union:

{"WUT?" | { hello: 'Guten Tag!'; time?: undefined; } | { time: 'Wie spat is es?'; hello?: undefined; }}

So what we may think is that if we use the function constraint by our generic by "discriminant union" type used inside the switch-case, it would return that particular branch type, like following:

// 🚨 NOPE !
// $ExpectType  {time: 'Wie spat is es?'}
const t1 = getUnion('ASK')

Unfortunately that's incorrect assumption as we're getting whole union instead of that one narrowed type

// ✅$ExpectType {"WUT?" | { hello: 'Guten Tag!'; time?: undefined; } | { time: 'Wie spat is es?'; hello?: undefined; }}
const t1 = getUnion('ASK')

Is this proper behaviour or rather Compiler limitation?

Anyways, how can this be solved?

So const t1 = getUnion('ASK') will return {time: 'Wie spat is es?'} ?

Answer 1

So what I came up with is following:

This implementation mitigates previous issue, as it properly returns narrowed type from return union by used function argument, via conditional types mapper:

type ProperReturn<T> = T extends 'GREET' ? {hello:'Guten Tag!'} : T extends 'ASK' ? {time:'Wie spat is es?'} : 'WUT'

function getUnionStrict<T extends Action>(action: T): ProperReturn<T> {
  switch (action) {
  case 'GREET':
    // 🍿it needs to be explicitly casted, which is OK I guess?
    return {hello: 'Guten Tag!' } as ProperReturn<T>
  case 'ASK':
    // 🍿 Cast needed
    return {time:'Wie spat is es?'} as ProperReturn<T>
  default:
    // 🍿 Cast needed
    return 'WUT?' as ProperReturn<T>
  }
}

// ✅ exactly what we wanted 
// $ExpectType {hello:'Guten Tag!'}
const t11 = getUnionStrict('ASK')

// ✅
// $ExpectType {time:'Wie spat is es?'}
const t22 = getUnionStrict('GREET')

Answer 2

One option is to use a mapping interface instead of using a conditional type, makes the return type easier to follow. Also I generally use a separate implementation signature with the generics and an implementation signature that is not generic and returns a union. While this is not 100% type safe it is better than the type assertion version.

type Action = 'GREET' | 'ASK'
interface ProperReturn {
  'GREET': { hello: 'Guten Tag!' }
  'ASK': { time: 'Wie spat is es?' }
}
function getUnion<T extends Action>(action: T): ProperReturn[T]
function getUnion(action: Action): ProperReturn[keyof ProperReturn] {
  switch (action) {
    case 'GREET':
      return { hello: 'Guten Tag!' } as const
    case 'ASK':
      return { time: 'Wie spat is es?' } as const
    default:
      throw "WUT";
  }
}

Playground Link

Answer 3

For searchers like me: I came up with a mix of the two answers, that I think is both type-safe and cleaner:

type ProperReturn = {
  'GREET': { hello: 'Guten Tag!' }
  'ASK': { time: 'Wie spat is es?' }
}

// better than retyping 'GREET' | 'ASK'
type Action = keyof ProperReturn

function getUnion<T extends Action>(action: T): ProperReturn[T] {
  switch (action) {
  case 'GREET':
    return {hello: 'Guten Tag!' } as ProperReturn[T]
  case 'ASK':
    return {time:'Wie spat is es?'} as ProperReturn[T]
  default:
    throw "WUT?"
  }
}

// t1: { hello: 'Guten Tag!'; }
const t1 = getUnion('GREET')

// t2: { time: 'Wie spat is es?'; }
const t2 = getUnion('ASK')

Playground link