Type Challenges: 00599-medium-merge Solution

Everyone's solution seems so complex. Here's a simple solution using built-in utility types. The mapped type is because the test wanted it expanded but the merging is all done in the generic. A simple Omit and &.

type Merge<A, B, M = Omit<A, keyof B> & B> = { [K in keyof M]: M[K] }

Solution by blazeshomida #35834

type Merge<F, S> = Omit<S & Omit<F, keyof S>, never>

Solution by gangnamssal #35591

type Merge<F, S> = {
  [key in keyof F | keyof S]: key extends keyof S
    ? S[key]
    : key extends keyof F
    ? F[key]
    : never;
};

Solution by RanungPark #35549

// your answers
type Merge<F, S> = {
	[Key in keyof  (F & S)]: Key extends keyof S ? S[Key] : Key extends keyof F ? F[Key] : never;
};

Solution by Sathiyapramod #35540

// your answers
type Merge<F, S> = {
	[Key in keyof F | keyof S]: Key extends keyof S ? S[Key] : Key extends keyof F ? F[Key] : never;
};

Solution by Sathiyapramod #35522

type foo = {
  name: string;
  age: string;
};

type coo = {
  age: number;
  sex: string;
};

type Result = Merge<foo, coo>;
// Result: { name: string; age: number; sex: string }

Solution by adultlee #35394

type Merge<F, S> = { [K in keyof F | keyof S]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }

Solution by eunsukimme #35240

type Merge<F, S> = {
  [Key in keyof F | keyof S] : Key extends keyof S ? S[Key] : Key extends keyof F ? F[Key] : never
}

Solution by devshinthant #34610

type Merge<F extends any, S extends any> =
  {
    [k in keyof (F & S)]: k extends keyof S ? S[k] : k extends keyof F ? F[k] : never
  }

Solution by Jayce-liang #34282

type Merge<F extends object, S extends object> = {
  [P in keyof F | keyof S]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never
}

Solution by ouzexi #34019

type Merge<T , V> = { [K in keyof T | keyof V] : K extends keyof V ? V[K] : K extends keyof T ? T[K]:never }

Solution by rookiewxy #33750

type Merge<F, S> = {
  [K in keyof F | keyof S] : K extends keyof S ? S[K] : K extends keyof F ? F[K] :never;
}

Solution by ckdwns9121 #33694

// 你的答案
type Merge<F extends Record<any, any>, S extends Record<any, any>> = {
  [K in keyof F | keyof S]: K extends keyof S ? S[K] : F[K]
}

Solution by HelloGGG #33416

type Merge<F, S> = {
  [P in keyof (F & S)]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never
}

Solution by loevray #33265

// 你的答案
type Merge<T, T2> = {
  [K in keyof T | keyof T2]: K extends keyof T2 ? T2[K] : K extends keyof T ? T[K] : never;
};

Solution by 2531800823 #33247

type Merge<F, S> = {
  [key in keyof F | keyof S]: key extends keyof F & keyof S 
    ? S[key] : 
    key extends keyof F 
      ? F[key] 
      : key extends keyof S ? S[key] : never;
}

Solution by ZhipengYang0605 #32832

type Merge<
    F extends Record<keyof F, unknown>,
    S extends Record<keyof S, unknown>,
    I = F & S
> = {
    [K in keyof I]:
        K extends keyof S
            ? S[K]
            : K extends keyof F
                ? F[K]
                : never
}

Solution by ZhulinskiiDanil #32702

type Merge<F extends object, S extends object> = 
  { [K in (keyof F | keyof S)]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }

Solution by dev-hobin #32415

type Flatten<T> = {
  [P in keyof T]: T[P]
}

type Merge<F, S extends Flatten<S>> = {
  [K in keyof Flatten<F & S>]: Flatten<F & S>[K] extends never ? S[K] : Flatten<F & S>[K]
};

Solution by keyurparalkar #32298

// your answers
type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
      ? F[K]
      : never
}

Solution by pea-sys #32218

type Merge<F, S> = Omit<F, keyof S> & S

Solution by rkamely #32062

type Merge<F extends Record<string, unknown>, S extends Record<string, unknown>> = {
	[K in keyof F | keyof S]: K extends keyof F & keyof S
		? S[K]
		: K extends keyof F
		? F[K]
		: K extends keyof S
		? S[K]
		: never;
};

Solution by gasmg #32015

type Merge<F, S> = {
  [P in keyof (F & S)] : P extends keyof (F | S) ? S[P] : (F & S)[P]
}

Solution by jinyoung234 #31814

type Merge<F, S> = {[key in keyof F | keyof S]: key extends keyof S ? S[key] : key extends keyof F ? F[key] : never }

Solution by kai-phan #31648

second argument overwrites first one

type Merge<F extends {}, S extends {}> = {[P in keyof (F & S)]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never}

Solution by ivannovazzi #31556

type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
    ? F[K]
    : never;
};

Solution by vipulpathak113 #31514

type Copy<T> = {
    [P in keyof T]: T[P];
}

type Merge<L, R> = Copy<Omit<L, keyof R> & R>;

Solution by sdrjs #31436

type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
      ? F[K]
      : never
}

Solution by bicochan #31396

type Merge<F, S> = {
  [M in (keyof F) | (keyof S)]: M extends keyof S
    ? S[M]
    : M extends keyof F
    ? F[M]
    : never;
};

Solution by HeeYeonKim98 #31358

type Merge<F, S> = {
    [K in keyof F | keyof S]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
}

Solution by ricky-fn #31299