Proposal: Add an "exclusive or" (^) operator

[mohsen1]

Based on this comment TypeScript does not allow exclusive union types.

I'm proposing a logical or operator similar to union (|) or intersection (&) operators that allows defining types that are one or another.

Code

type Person = { name: string; } ^ { firstname: string; lastname: string; };

const p1: Person = { name: "Foo" };
const p2: Person = { firstname: "Foo", lastname: "Bar" } ;

const bad1: Person = { name: "Foo", lastname: "Bar" }
 ~~~~~~~~~~~~~~~ Type Person can not have name and firstname together 
const bad2: Person = { lastname: "Bar", name: "Foo" } 
 ~~~~~~~~~~~ Type Person can not have lastname and name together

For literal and primitive types it should behave like union type:

// These are the same 
type stringOrNumber = string | number;
type stringORNumber = string ^ number;

[mhegazy]

The issue is there are no exact/final types in TS. all types are open ended. so this is allowed from an assignable perspective:

var p1: {name: string };
var p2 = {name:"n", firstName: "f", lastName: "l"};
p1 = p2; // OK

A type is assignable to a union type, iff it is assignable to one of the constituents. so even with the exclusive union, open types would allow that check to pass.

Another feature that TS has is flagging "unknown" properties. This only applies to object literals, that happen to have a contextual type. e.g.:

var p: {name: string} = { name: "n", another: "f" }; // Error `another` is not a known property

This check is simplified for union types, just to say it has to be a "known" property on the union in general, not for this constituent. The main issue here is how unions are compared, when we are comparing constituent types, we do not know if we should check for "unknown" properties, because it might be one of the other types.

If i am not mistaken, you are after this unknown property check in this case. I would say we are better off trying to change how this is handled for unions, rather than creating a new concept in the language that users need to understand.

Related discussion in #12997. Issue tracked by #12745

[mohsen1]

#12745 will solve parts of this problem. But it won't have exclusive or logic because tagged unions are merging assignable types. For example:

interface A { foo: string; }
interface B { bar: string; }

type C = A | B;

const a: C = { foo: '' } // Wrongfully ✔ // Hopefully #12745 fixes this
const b: C = { bar: '' } // Wrongfully ✔ // Hopefully #12745 fixes this
const c: C = { foo: '', bar: '' } // ✔

What I'm suggesting is an exclusive or operator between two interfaces:

interface A { foo: string; }
interface B { bar: string; }

type C = A ^ B;

const a: C = { foo: '' } // ✔
const b: C = { bar: '' } // ✔
const c: C = { foo: '', bar: '' } // ❌

[mhegazy]

without exact types the new operator does not solve the issue, since {foo: '', bar: '' } is still a {foo: string}

[mukhuve]

This would be really helpful, Allows better management in development time.

[RyanCavanaugh]

Presumably the behavior here would be that

type A = { m: T } ^ { n : U };

is equivalent to

type A = { m: T, n: undefined } | { m: undefined, n : U };

[mohsen1]

@RyanCavanaugh it makes it even easier to implement as de-sugar algorithm is so easy!

This operator is still a good idea since there are lots of cases where an API expect two or more completely different interfaces.

Adding undefined can pile up quickly:

type A = { m: T } ^ { n: U } ^ { o: Q }

vs.

type A = 
 { m: T; n: undefined; o: undefined; } |
 { m: undefined; n: U; o: undefined; } |
 { m: undefined; n: undefined; o: Q; }

[RyanCavanaugh]

Search terms so I can find this later: "mutually exclusive" "disjoint unions"

[battmanz]

I'd like to add another use case for this feature. I'm currently using json-schema-to-typescript to generate TypeScript interfaces from JSON Schema. Currently the "oneOf" keyword is listed as not expressible in TypeScript. Having exclusive unions would then make it expressible.