Defined Partial Record

In this medium-level challenge, you'll implement DefinedPartial<T> which creates a union of all non-empty subsets of an object type, so that present keys have defined (non-undefined) values and absent keys simply do not exist on the type.

const record: Record<'a' | 'b' | 'c', number> = { a: 42, b: 10 }
// error: Property 'c' is missing in type '{ a: number; b: number; }'
// but required in type 'Record<"a" | "b" | "c", number>'

const partial: Partial<Record<'a' | 'b' | 'c', number>> = { a: 42 }
const partialType = typeof partial // { a?: number | undefined, b? : number | undefined, c? : number | undefined }
const operation = 0 + partial.a // error: 'partial.a' is possibly 'undefined'
const access = partial.c // possible, type doesn't know that there is no such key

const best: DefinedPartial<Record<'a' | 'b' | 'c', number>> = { a: 42 }
const sum = 0 + best.a // 42
const error = best.b // error: property 'b' does not exist on type '{ a: number; }'

type A1 = Record<'a' | 'b', string>
type E1 = { a: string } | { b: string } | { a: string; b: string }
type D1 = DefinedPartial<A1>
type C1 = Expect<Equal<D1, E1>>

type A2 = Record<'a' | 'b' | 'c', string>
type E2 =
  | { a: string }
  | { b: string }
  | { c: string }
  | { a: string; b: string }
  | { a: string; c: string }
  | { b: string; c: string }
  | { a: string; b: string; c: string }
type D2 = DefinedPartial<A2>
type C2 = Expect<Equal<D2, E2>>

type A3 = Record<'a', number>
type E3 = { a: number }
type D3 = DefinedPartial<A3>
type C3 = Expect<Equal<D3, E3>>

type A4 = Record<'a', nu

Detailed Explanation

type DefinedPartial<T, K extends keyof T = keyof T> =
  [K] extends [never]
    ? never
    : K extends keyof T
      ? { [P in K]: T[P] } | DefinedPartial<T, Exclude<keyof T, K>>
        | { [P in K]: T[P] } & DefinedPartial<T, Exclude<keyof T, K>> extends infer U
          ? U extends object ? { [P in keyof U]: U[P] } : never
          : never
      : never

A cleaner recursive approach that generates the powerset of keys:

type Powerset<K extends PropertyKey> = K extends K
  ? { [P in K]: unknown } | (Powerset<Exclude<K, K>> extends never ? never : never)
  : never
 
type DefinedPartial<T, K extends keyof T = keyof T> =
  K extends keyof T
    ? Pick<T, K> | Merge<Pick<T, K> & DefinedPartial<T, Exclude<keyof T, K>>>
    : never
 
type Merge<T> = { [K in keyof T]: T[K] }

The most straightforward correct solution distributes over each key and builds up combinations:

type DefinedPartial<T, K extends keyof T = keyof T> =
  K extends keyof T
    ? Pick<T, K> | (
        DefinedPartial<T, Exclude<keyof T, K>> extends infer Rest
          ? Rest extends any
            ? { [P in keyof (Pick<T, K> & Rest)]: (Pick<T, K> & Rest)[P] }
            : never
          : never
      )
    : never

How it works:

• The type distributes over each key K using the K extends keyof T distributive conditional
• For each key, Pick<T, K> creates a single-key object like { a: string }
• DefinedPartial<T, Exclude<keyof T, K>> recursively computes all non-empty subsets of the remaining keys
• Each recursive result Rest is intersected with Pick<T, K> and flattened using a mapped type, producing multi-key combinations like { a: string; b: string }
• The union of single-key picks and combined results yields the full powerset minus the empty set
• The base case implicitly terminates when K is never (no more keys to distribute over), producing never

This challenge helps you understand powerset generation at the type level using distributive conditional types and how to apply this concept in real-world scenarios.