Get an `Object` that is the difference between O & O1

Question

There was this type challenge:

Get an Object that is the difference between O & O1

I came up with such solution but I wonder if you have advice to simplify my approach?

My solution:

type Diff<O extends object, O1 extends object, tmp extends object ={[k in keyof O]: k extends keyof O1 ? never:O[k]} &{[k in keyof O1]: k extends keyof O ? never:O1[k]}  > = Filter<tmp,NonNeverKeys<tmp>>

Where

type NonNeverKeys<T extends object > = {
  [K in keyof T]-?: T[K] extends never ? never : K
}[keyof T];

and

type Filter<T extends object, V extends keyof T> = {
  [K in V]-?: T[K]};

Explanation:

• If you do Diff<Foo, Bar> then tmp holds (Foo,Bar below):

    {
        name: never;
        age: never;
    } & {
        name: never;
        age: never;
        gender: number;
    }
  

Then I use my helpers to first extract key names which aren't never from above intersection, and then filter above intersection using extracted keys.

Test cases:

type Foo = {
  name: string
  age: string
}
type Bar = {
  name: string
  age: string
  gender: number
}
type Coo = {
  name: string
  gender: number
}

type cases = [
  Expect<Equal<Diff<Foo, Bar>, { gender: number }>>,
  Expect<Equal<Diff<Bar, Foo>, { gender: number }>>,
  Expect<Equal<Diff<Foo, Coo>, { age: string; gender: number }>>,
  Expect<Equal<Diff<Coo, Foo>, { age: string; gender: number }>>,
]

I tried to solve without using helper TS types like Exclude etc.

Answer 1

You can make this easier by using the Venn diagram

Let's say we have two sets A and B. All you need is the union of A - B and B - A. How can we get them if we only know A and B?

First of all we need to find two things: the union (∪) of A and B and the intersection (∩) of A and B. Why?

As we see in the diagram

• A = (A - B) ∪ A∩B
• B = (B - A) ∪ A∩B

Now we can see that

• A - B = A - A∩B
• B - A = B - A∩B

We need union of A - B and B - A: (A - B)∪(B - A) = A∪B - A∩B - A∩B. In terms of sets, subtraction the same thing twice is useless so we can subtract only one time, so the final formula:

(A - B)∪(B - A) = A∪B - A∩B

In TypeScript the union of two types can be defined with & operator:

type Union<T1, T2> = T1 & T2;

The intersection of two types can be defined in this way (original post):

type Intersection<T1, T2> = {
  [K in keyof T1 & keyof T2]: T1[K] | T2[K]
}

So all we need is use Omit to get the difference

type Diff<T1, T2> = Omit<Union<T1, T2>, keyof Intersection<T1, T2>>

Example

UPD

Sorry I didn't notice this "I tried to solve without using helper TS types like Exclude". It is not a problem we can define our type MyOmit

In the source of Omit we can see that Omit defined as:

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>

So we need to define our MyExclude and MyPick to define MyOmit as:

type MyOmit<T, K extends keyof any> = MyPick<T, MyExclude<keyof T, K>>

As it described in source we can define MyExclude like this:

type MyExclude<T, U> = T extends U ? never : T

MyPick we also can define as it described in source:

type MyPick<T, K extends keyof T> = {
    [P in K]: T[P];
}

I know that you can say "Hey! You just copied the code from source it is not your implementation!" and you will be absolutely right. But I don't think that I must to invent a bicycle :) It is better to understand how it works and then use it anywhere

Lets start with the easiest type MyPick:

1. Pick<T, K extends keyof T> here we use K extends keyof T to define that we can pass only the keys which are in type T

2. [P in K] it works similar as in JS loop for..in, we just list object keys

3. T[P] means that for each key P we define exactly the type which defined in type T

The type MyExclude also not so hard but it will be easier to understand on specific example. Lets say that T = 'a' | 'b' | 'c' and U = 'a' | 'b'

Then we have to deal with 3 cases:

1. 'a' extends 'a' | 'b' ? never : T - yes 'a' extends 'a' | 'b', so the answer is never
2. 'b' extends 'a' | 'b' ? never : T - yes 'b' extends 'a' | 'b', so the answer is never
3. 'c' extends 'a' | 'b' ? never : T - no 'c' extends 'a' | 'b', so the answer is 'c'

Now we have:

MyExclude<T, U> = MyExclude<'a' | 'b' | 'c', 'a' | 'b'> = never | never | 'c' = 'c'

The final code:

type Union<T1, T2> = T1 & T2;

type Intersection<T1, T2> = {
  [K in keyof T1 & keyof T2]: T1[K] | T2[K]
}

type MyPick<T, K extends keyof T> = {
    [P in K]: T[P];
};

type MyExclude<T, U> = T extends U ? never : T;

type MyOmit<T, K extends keyof any> = MyPick<T, MyExclude<keyof T, K>>

type Diff<T1, T2> = MyOmit<Union<T1, T2>, keyof Intersection<T1, T2>>

Example

Answer 2

OP here posted question as guest. I found one solution which indirectly uses Excludes kind of logic after as:

type Diff<O extends object, O1 extends object,  > = FilterNever<{[k in keyof O]: k extends keyof O1 ? never:O[k]} &{[k in keyof O1]: k extends keyof O ? never:O1[k]} >
 
type FilterNever<Type> = {
    [Property in keyof Type as Type[Property] extends never ? never:Property]: Type[Property]
};