Description
Bug Report
🔎 Search Terms
- generic types not equal
🕗 Version & Regression Information
- This is the behavior in every version I tried, and I reviewed the FAQ for entries about generics.
⏯ Playground Link
Playground link with relevant code
💻 Code
// These are the types of records in the database.
type TableToRecord = {
a: { a: number }
b: { b: string }
c: { c: string[] }
}
type Table = keyof TableToRecord
// Create a union of {table, id} objects.
type Pointer<T extends Table = Table> = {
[K in T]: {table: K, id: string}
}[T]
// Hover X to see this is a proper union type
type X = Pointer
// ✅ this works as expected.
declare function getRecord<T extends Table>(pointer: Pointer<T>): TableToRecord[T]
const x = getRecord({table: "a", id: ""})
// ❌ this surprisingly doesn't work
declare function something(pointer: Pointer): void
const p: Pointer<"a"> = {table: "a", id: ""}
something(p)
function run<T extends Table>(pointer: Pointer<T>) {
const x = something(pointer)
}
// ✅ However, this does work if run is generic on Pointer instead of Table.
declare function something2(pointer: Pointer): void
function run2<P extends Pointer>(pointer: P) {
const x = something(pointer)
}
// ✅ Which then makes me wonder if its better to write getRecord this way
declare function getRecord2<P extends Pointer>(pointer: P): TableToRecord[P["table"]]
const x2 = getRecord2({table: "a", id: ""})🙁 Actual behavior
I'm surprised by this error where Pointer<T> where T extends Table doesn't satisfy the argument Pointer<Table>.
If we were talking arrays, Array<T> where T extends string | number, I'd imagine you should be able to pass that to a function that accepts Array<string | number> as an argument. But it is a bit tricky if that argument gets mutated by the function, e.g. pushing a number onto a string array. I think there's a fancy type-system word for this behavior?
But as I understand it, TypeScript is all structural comparison and since Pointer<T> unfurls into the union type, I'm curious where the problem lies and it seems to me like the type system should let this work...
I noticed when the generic param is P extends Pointer instead of T extends Table and then using Pointer<T>, then the code does work. But then that leads me to wonder if there's any difference between function getRecord<T extends Table>(pointer: Pointer<T>): TableToRecord[T] and function getRecord2<P extends Pointer>(pointer: P): TableToRecord[P["table"]] ...