Conditional type produced different behavior when used in generic type

[unional]

🔎 Search Terms

conditional type, generic type, behavior

🕗 Version & Regression Information

tested on 5.2.2

⏯ Playground Link

https://www.typescriptlang.org/play?#code/C4TwDgpgBAGlC8UB2EBuEBOUIA9gSQBMBnKAewCMArCAY2CgH4pgMBXaALigDMBDADbEIAKBGhIUAEoAeACoA+BFDnY8BEuWp0GzVhyjd+Q0ePDQAmstkp0GBSKA

💻 Code

type X = never extends object ? true : false // true

type R<T> = T extends object ? true : false

type Y = R<never> // never

🙁 Actual behavior

type X = never extends object ? true : false // true

type R<T> = T extends object ? true : false

type Y = R<never> // never

🙂 Expected behavior

type X = never extends object ? true : false // true

type R<T> = T extends object ? true : false

type Y = R<never> // true

Additional information about the issue

No response

[jcalz]

#23182

[MartinJohns]

https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types

[unional]

Yes it is the same issue. But this case is even harder to reason because when it is not a generic type, it is evaluated as an empty set, but with generic type, it is evaluated as an empty union.

[fatcerberus]

Yes it is the same issue. But this case is even harder to reason because when it is not a generic type, it is evaluated as an empty set, but with generic type, it is evaluated as an empty union.

You're overthinking it--never is always best thought of as an empty union. The observed difference in behavior is down to whether the conditional type distributes over it or not, just like with any other union type. That happens whenever the input to the conditional type is a single naked type parameter.

[MartinJohns]

Yes it is the same issue. But this case is even harder to reason because when it is not a generic type, it is evaluated as an empty set, but with generic type, it is evaluated as an empty union.

When it's a generic type it's evaluated distributive, when it's not a generic type it's not.

[unional]

Yes, maybe.

What I'm really dealing with is defining types with straight forward behavior over the special types: any, unknown, never, (and void).

For example:

type Merge<A extends Record<any, any>, B extends Record<any, any>> = ...

Merge<{ a: 1 }, any>
Merge<{ a: 1 }, never> // this is allowed due to the issue here, I think

I found myself needs to add special handling for never of every type, as the type constraint always allow never to go through.

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.