TypeScript interface with XOR, {bar:string} xor {can:number}

Question

How do I say that I want an interface to be one or the other, but not both or neither?

interface IFoo {
    bar: string /*^XOR^*/ can: number;
}

score 88 · Accepted Answer · edited Feb 23 '22 at 09:50

88

You can use union types along with the never type to achieve this:

type IFoo = {
  bar: string; can?: never
} | {
  bar?: never; can: number
};


let val0: IFoo = { bar: "hello" } // OK only bar
let val1: IFoo = { can: 22 } // OK only can
let val2: IFoo = { bar: "hello",  can: 22 } // Error foo and can
let val3: IFoo = {  } // Error neither foo or can

edited Feb 23 '22 at 09:50

Peter

37,042
39
142
198

answered Jun 08 '17 at 02:02

Saravana

37,852
18
100
108

3

Brilliant! I never realized `never` can be used to forbid a key from being present! – hasen Jun 08 '17 at 07:51
1

Great, that's what I was after. `+1` & accepted – A T Jun 10 '17 at 07:52
@AT somehow its not accepted – godblessstrawberry Oct 26 '20 at 12:28
1

@godblessstrawberry My bad! - Accepted. – A T Oct 27 '20 at 00:09
1

This work and it shouldn't: `let val2: IFoo = { bar: "hello", can: undefined }` – refaelio Mar 11 '21 at 14:27

score 33 · Answer 2 · answered Nov 09 '18 at 16:40

33

As proposed in this issue, you can use conditional types (introduced in Typescript 2.8) to write a XOR type:

type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;

And you can use it like so:

type IFoo = XOR<{bar: string;}, {can: number}>;
let test: IFoo;
test = { bar: "test" } // OK
test = { can: 1 } // OK
test = { bar: "test",  can: 1 } // Error
test = {} // Error

answered Nov 09 '18 at 16:40

Guilherme Agostinelli

1,432
14
13

Fancy.................................. – A T Nov 11 '18 at 08:18
9

What about `XOR` for more than two type? – trusktr Feb 23 '19 at 00:10
@trusktr I think it boilds down to [variadic generics](https://github.com/microsoft/TypeScript/issues/1773) in combination with TS3.1. Unfortunately I have not come up with a solution for this myself yet. But I can think of using Head, Tail, HasTail and recursion as demonstrated here: https://www.freecodecamp.org/news/typescript-curry-ramda-types-f747e99744ab/. On the downside of things, this does not check on the permutation set and I do not know if that does collide with operations in set theory (such as triangle inequality). – tafaust May 10 '20 at 09:12
You can solve this with the given `XOR` type by doing `XOR>>` - just keep going to add more types. – Edy Bourne Aug 07 '22 at 22:44
Another suggestion I came up w/ before finding your amazing answer ```type Not = {[key in keyof T ]?: never}; type XOR = (A & Not) | (Not & B);``` I was trying to base myself on mathematical logic and the XOR formula – Daniel Aragão Jan 11 '23 at 00:18

score 5 · Answer 3 · answered Jun 08 '17 at 01:53

5

You can get "one but not the other" with union and optional void type:

type IFoo = {bar: string; can?: void} | {bar?:void; can: number};

However, you have to use --strictNullChecks to prevent having neither.

answered Jun 08 '17 at 01:53

artem

46,476
8
74
78

score 1 · Answer 4 · answered Jun 08 '17 at 01:53

try this:

type Foo = {
    bar?: void;
    foo: string;
}

type Bar = {
    foo?: void;
    bar: number;
}

type FooBar = Foo | Bar;

// Error: Type 'string' is not assignable to type 'void'
let foobar: FooBar = {
    foo: "1",
    bar: 1
}

// no errors
let foo = {
    foo: "1"
}

TypeScript interface with XOR, {bar:string} xor {can:number}

4 Answers4

Linked

Related