Covariance in intersection

[f3oall]

🔎 Search Terms

covariance

🕗 Version & Regression Information

Checked on 5.8.3 and nightly, showing error.

⏯ Playground Link

https://www.typescriptlang.org/play/#code/KYDwDg9gTgLgBDAnmYcCCATDBFArsAZxgEsIA7AWQEMoBrAgHgBU5QZgyMC4IAjAK2ABjGAD44AXjgBvAFBw4AbQDScYmTi1giCADM4LKt1ydgu9cAysQ7TtyYqAunAD8cMsABuwKHABccMqOAQ5BsgC+cABkMvJKquqa2noGcEZwJhhmFlZsHFwGTq6B-u5ePo4uIU4RsnWgkLBwQgA2RtwAygAWVCgMELjwAPLWtgV8giLicgpZrTSoAPoDMGCDASO1sgD02+hYeIQk5NR03GBQEBi4QoTNEJ40xFRkMAA0cLyD9wC2YMQtHxwDAQQhkADk8BgXXUtDgBAgsga0Hg8wI3DQ-W+HVG+U6PRQ0ziczaUCWKzWMACmBw+CIpEoNHoDA6inBy0GlPBjlEESAA

💻 Code

export type AddQuestionMarks<T extends object> = {
  [K in keyof T as undefined extends T[K] ? never : K]: T[K]
} & {
  [K in keyof T as undefined extends T[K] ? K : never]?: T[K]
}


export class Shape<out O extends object> {
  declare _output: O 
}

// AddQuestionMarks produces covariant, but compiler doesn't think so
export class A<out S extends Shape> {
  declare _output: AddQuestionMarks<S['_output']>
}

🙁 Actual behavior

I'm new to the whole variance thing, but it seems like compiler can't properly determine it in this case, AddQuestionMarks ruins covariance, despite it shouldn't.

If I'm wrong, any explanation would be great. If you have any suggestions on how to implement AddQuestionMarks in different way without ruining covariance, let me know as well.

🙂 Expected behavior

Result of AddQuestionMarks should be compatible with covariance or we should be able to explicitly set out on this type.

Additional information about the issue

No response

[jcalz]

you have out S extends Shape but Shape requires a type argument. Is that a typo?

[LukeAbby]

This doesn't have anything to do with the intersection involved. This essentially has to do with the fact that T is in both a covariant and contravariant position making it invariant even though T being covariant would be fine.

The covariant position here is the mapping of T as a whole; the thing being mapped is put into a covariant position (the T in { [K in keyof T as ... ]: ... } in this case). The contravariant position here is the usage of T in the key remapping. More specifically the T[K] in as undefined extends T[K] ? never : K.

Here's a boiled down example:

export type Remap<T extends object> = {
  [K in keyof T as T extends "foo" ? K : K]: unknown;
}

export class A<out S extends object> {
// Type 'A<sub-S>' is not assignable to type 'A<super-S>' as implied by variance annotation.
//   Types of property '_output' are incompatible.
//    Type 'Remap<sub-S>' is not assignable to type 'Remap<super-S>'.
  declare _output: Remap<S>
}

The expression as T extends "foo" ? K : K may feel identical to as K but TypeScript can't prove it. In this specific case that's actually a good thing! This is because they aren't identical: T extends "foo" ? K : K is actually never when T is never, not K. In your case that's more of a frustrating stumbling block though.