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 39 · Accepted Answer · answered Jun 08 '17 at 02:02

39

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

answered Jun 08 '17 at 02:02

Saravana

28,153
11
81
94

2

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
This work and it shouldn't: `let val2: IFoo = { bar: "hello", can: undefined }` – refaelio Mar 11 '21 at 14:27

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

18

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

802
8
13

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

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). – tahesse May 10 '20 at 09:12

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

4

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

29,391
6
61
63

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