My solution for type challenge https://github.com/type-challenges/type-challenges

AppendArgument.ts

type AppendArgument<Fn, A> = Fn extends (...args: infer Args) => infer R
  ? (...args: [...Args, A]) => R
  : never

Currying.ts

type TheActualCurry<T,R> = T extends [infer F, ...infer S]
  ? (...args: [F]) => TheActualCurry<S,R>
  : R

declare function Currying<T extends readonly any[], R>(fn: (...args: [...T]) => R): TheActualCurry<T,R>

DeepReadOnly.ts

type DeepReadonly<T extends Record<string, any>> = {
  readonly [k in keyof T]: T[k] extends number | boolean | string | Function
    ? T[k]
   : DeepReadonly<T[k]>
}

Exclude.ts

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

First.ts

type First<T extends any[]> = T[0] extends undefined ? never : T[0]

If.ts

type If<C, T, F> = C extends boolean ? C extends true ? T : F : never

Last.ts

type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never

Length.ts

type Length<T extends readonly any[]> = T["length"]

Lookup.ts

type WithType<T> = {
  type: T
}

type LookUp<U, T> = U extends WithType<T> ? U : never

Omit.ts

type MyOmit<T, K extends keyof T> = {
  [k in Exclude<keyof T, K>]: T[k]
}

Pick.ts

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

Pop.ts

type Pop<T extends any[]> = T extends [...infer A, any] ? A : never

PromiseAll.ts

// not finished, failed on case 3
type ResolvePromise<T> = T extends Promise<infer U> ? U : T
type ResolvePromises<T> = { -readonly[P in keyof T]: ResolvePromise<T[P]> }

declare function PromiseAll<T extends readonly any[]>(values: T): Promise<ResolvePromises<T>>

ReadOnly.ts

type MyReadonly<T> = {
  readonly [k in keyof T]: T[k]
}

ReturnType.ts

type MyReturnType<T> = T extends (...args: any[]) => infer U ? U : any

TupleToObject.ts

type TupleToObject<T extends readonly any[]> = {
  [k in T[number]]: k
}

TupleToUnion.ts

type TupleToUnion<T extends readonly any[]> = T[number]