Transform generic of union to union of generic type.

[ccorcos]

I've run into the following type of inferencing problem several times now:

// These are database tables.
type Table = "a" | "b" | "c"

// These are the types of records in the database.
type TableToRecord = {
	a: { a: number }
	b: { b: string }
	c: { c: string[] }
}

// This object tells you a record with its table.
type RecordWithTable<T extends Table> = {
	table: T,
	record: TableToRecord[T]
}

// I might want to have a function to process any record in my database.
// However, there's a type error that doesn't let you narrow the generic type
// argument.
function processRecord<T extends Table>(recordWithTable: RecordWithTable<T>) {
	if (recordWithTable.table === "a") {
		const x = recordWithTable.record.a // error
	}
}

Not entirely sure why Typescript can't handle this case... I assume someone is going to say it has to do with type widening or something. Regardless, we can solve this problem if we transform the "generic of a union type" to a "union of a generic type". For example, the following will type narrow properly.

function processRecord2(
	recordWithTable:
		| RecordWithTable<"a">
		| RecordWithTable<"b">
		| RecordWithTable<"c">
) {
	if (recordWithTable.table === "a") {
		const x = recordWithTable.record.a // no error
	}
}

Suggestion

What would be really cool is if there was a baked in Typescript type that let you make this transformation. Maybe something like this:

type RecordWithTableUnion = MapUnion<Table, RecordWithTable>

// Equivalent to explicitly writing it out.
type RecordWithTableUnion = 
	| RecordWithTable<"a">
	| RecordWithTable<"b">
	| RecordWithTable<"c">

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript / JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. new expression-level syntax)

playground

[AlCalzone]

This gets you there half of the way:

type Union = "a" | "b" | "c";
type Generic<T> = { something: T };
type GenericOfUnion<U extends string> = { [K in U]: Generic<K> }[U];
type Foo = GenericOfUnion<Union>; // Generic<"a"> | Generic<"b"> | Generic<"c">

You cannot pass Generic as an operator though, as that would require higher kinded types (if I understand correctly).

[jack-williams]

Not entirely sure why Typescript can't handle this case... I assume someone is going to say it has to do with type widening or something. Regardless, we can solve this problem if we transform the "generic of a union type" to a "union of a generic type". For example, the following will type narrow properly.

TypeScript only narrows by filtering unions, or by assertion (adding & T). Neither of these cases help in your example, though you can get the right 'narrow-by-assertion' behavior with a type guard:

function narrow<T extends Table>(t:T, x: any): x is RecordWithTable<T> {
  return x.table === t;
}

function processRecord<T extends Table>(recordWithTable: RecordWithTable<T>) {
  if (narrow("a",recordWithTable)) {
    const x: number = recordWithTable.record.a // no error
  }
}

[ccorcos]

TypeScript only narrows by filtering unions, or by assertion (adding & T)

That's actually really helpful to think about. Thanks.

---

Both of these are helpful suggestions. @jack-williams's approach is simple but doesn't produce the correct type. processRecord works without the generic at all. That's wrong.

function processRecord(recordWithTable: RecordWithTable<Table>) {
	if (narrow("a", recordWithTable)) {
		const x = recordWithTable.record.a // error
	}
}

function narrow<T extends Table>(t:T, x: RecordWithTable<Table>): x is RecordWithTable<T> {
  return x.table === t;
}

@AlCalzone works pretty nicely actually.

type RecordsWithTables<U extends Table> = { [K in U]: RecordWithTable<K> }[U];
type x = RecordsWithTables<Table>

I still think it would still be nice if there was some syntax available for doing this.

[jack-williams]

@ccorcos

@jack-williams's approach is simple but doesn't produce the correct type. processRecord works without the generic at all. That's wrong.

Yes my type doesn't produce a union of constrained values (is that what you mean?), but it does let you narrow them.

Another encoding of RecordsWithTables:

type RecordsWithTables<T> = T extends Table ? RecordWithTable<T> : never;
type y = RecordsWithTables<Table>;