Disallow intersection of exact objects

[villesau]

Proposal

Intersections of exact objects does not make sense since they produce impossible type that can't be used. {| a: number|} & {| b: string |}produces an object type that only has property a and nothing else, but also has property b and nothing else. This indicates that intersections can only be used for inexact objects.

In optimal case the error message would be describing and maybe communicate why intersection of exact objects can't be used and suggest to use spreading instead.

This is important especially for newcomers and people who are used to write TS. I find my self very often explaining how and why intersection of exact objects can't be used.

I understand that this might not be big deal for FB, but for community it's important to make experience good for newcomers.

[SillyFreak]

There are corner cases where the intersection type is not empty:

type A = {|
  foo: number | string,
|};

type B = {|
  foo: bool | string,
|};

let x: $ReadOnly<A&B> = { foo: 'a', };

or

type A = {|
  a?: number,
  c: number,
|};

type B = {|
  b?: number,
  c: number,
|};

let x: $ReadOnly<A&B> = { c: 0, };

($ReadOnly prevents adding properties to x that would make the object no longer conform to its intersection type)

But I agree that warning against empty intersections of exact types would be useful in most cases and to a lot of people.

[villesau]

@SillyFreak Interesting, hadn't thought about those cases! Anyhow, do you think there would be any real world use cases with them that couldn't be achieved easily in other ways?

[SillyFreak]

real world use cases I'm not sure, but disallowing intersection types in this specific circumstance, because there are workarounds for when this is actually the desired behavior seems like the wrong approach. Maybe a lint would make sense, but disallowing this seems too harsh.

In principle it should be possible to determine when the resulting type is empty, and disallowing such types (including number & string) would IMO make more sense than the "heuristic" of exact object intersections. But even then, empty types are not entirely useless. Take this function:

function throws(): void { throw new Error(); }

void is not the most specific type that I could use here: void's only value is undefined, but this function never returns undefined. I could specify number & string as well.