Function type assignability with generic parameters | TypeScript Community | Page 1

potent basalt Sep 17, 2024, 10:31 AM

#

Hi! I'm trying to understand an error I'm getting when assigning a function type that accepts a wider set of potential values to a type that accepts a narrower set. See playground link below for a reproduction.

The main thing that confuses me is the error Type 'PartialBook[Key]' is not assignable to type 'Book[Key]'. Shouldn't this be the other way around, with me assigning the function that takes Book[Key] to a function type that takes PartialBook[Key]?

I remember reading about this particular behaviour before, but I can't find the relevant discussion or docs. Any clarification on what's happening here would be appreciated!

limpid cradleBOT Sep 17, 2024, 10:32 AM

#

dragory#0

Playground Link

Preview:```ts
interface Book {
id: number
name: string
pages: number
created_at: string
}

type FnThatUsesAllBookKeys = <Key extends keyof Book>(
key: Key,
value: Book[Key]
) => void

type PartialBook = Pick<Book, "name" | "pages">

type FnThatUsesSomeBookKeys = <
Key extends keyof PartialBook

(
key: Key,
value: PartialBook[Key]
) => void
...```

quiet flint Sep 17, 2024, 10:35 AM

#

!:vari%

limpid cradleBOT Sep 17, 2024, 10:35 AM

#

tjjfvi#0

`!t6:variance`:

Here's the example with Dog and Animal, explaining co/contra/in variance:

Covariance: () => Dog is assignable to () => Animal, because Dog is assignable to Animal; it "preserves the direction of the assignability"
Contravariance: (Animal) => void is assignable to (Dog) => void, because something that expects an Animal can also take a Dog; it "reverses the direction of the assignability"
Invariance: (Animal) => Animal is not assignable to (Dog) => Dog, because not all returned Animals are Dogs, and (Dog) => Dog is not assignable to (Animal) => Animal, because something expecting a Dog cannot take any other kind of Animal

quiet flint Sep 17, 2024, 10:35 AM

#

this?

#

Book is a narrower type than Partial<Book>, because it requires the keys all exist

potent basalt Sep 17, 2024, 10:41 AM

#

Hmm.. wouldn't the use case here be sound though? If you're expecting the function to take any of the keys of PartialBook and the corresponding value, shouldn't a function that takes any of the keys of Book (and a corresponding value) be assignable there as well?

potent basalt Sep 17, 2024, 10:42 AM

#

quiet flint Book is a narrower type than Partial<Book>, because it requires the keys all exi...

This does highlight why it fails, though -- in my mind, PartialBook was the more narrow type (which it obviously is not). Thanks!

potent basalt Sep 17, 2024, 10:44 AM

#

potent basalt Hmm.. wouldn't the use case here be sound though? If you're expecting the functi...

That said, I'd still like to understand this though ^. I get that it fails because of contravariance, so something here has to be unsound, but I can't see what.

#

And in fact, the opposite fails here too (which makes sense to me, as FnThatUsesSomeBookKeys can't handle the missing 2 keys):

limpid cradleBOT Sep 17, 2024, 10:49 AM

#

dragory#0

Playground Link

Preview:ts ... const test: FnThatUsesAllBookKeys = (() => {}) as FnThatUsesSomeBookKeys ...

quiet flint Sep 17, 2024, 11:04 AM

#

i hadn't checked the playground before, since i was on mobile. im on pc now, give me a sec

#

oh that's a weird case.

#

i thought PartialBook was Partial<Book> before

quiet flint Sep 17, 2024, 11:11 AM

#

limpid cradle

it makes sense that this fails, but idk why the original case is failing

#

let me reduce it a bit.

#

a lot of things appear to fix the error, and i have no clue why lmao

limpid cradleBOT Sep 17, 2024, 11:18 AM

#

that_guy977#0

Playground Link

Preview:```ts
interface X {
a: string;
b: string; // making b and c the same type fixes
c: number;
}

type ConsumeX = <Key extends keyof X>(key: Key, value: X[Key]) => void; // removing this generic fixes

type HalfX = Pick<X, "b" | "c">; // removing either b or c fixes
...```

potent basalt Sep 17, 2024, 11:20 AM

#

that is such a weird thing that removing either b or c fixes it there, lol

#

okay, in the original, changing the Pick to only use properties with the same type also works

quiet flint Sep 17, 2024, 11:21 AM

#

well since removing generics fixes it, it's something weird with variance and generics, i guess

potent basalt Sep 17, 2024, 11:21 AM

#

yeah, I imagine so

#

this works, for example:

limpid cradleBOT Sep 17, 2024, 11:23 AM

#

dragory#0

Playground Link

Preview:```ts
...
function withExtendedFn<
Fn extends FnThatUsesSomeBookKeys

(fn: Fn) {}
withExtendedFn((() => {}) as FnThatUsesAllBookKeys)
...```

potent basalt Sep 17, 2024, 11:25 AM

#

as does this:

limpid cradleBOT Sep 17, 2024, 11:25 AM

#

dragory#0

Playground Link

Preview:ts ... function withExtendedFn<T extends PartialBook>( fn: FnWithKeys<T> ) {} withExtendedFn((() => {}) as FnWithKeys<Book>) withExtendedFn((() => {}) as FnWithKeys<PartialBook>) ...

potent basalt Sep 17, 2024, 11:25 AM

#

so I might have to just pull the generic up a level here

#

I'll leave this thread open in case someone has insight into what's happening here exactly, but thank you for the help!

quiet flint Sep 17, 2024, 11:28 AM

#

there are plenty of wizards with deeper knowledge than me, perhaps one of them can provide some insight lol

static dragon Sep 17, 2024, 2:06 PM

#

@potent basalt The easiest way is to not use generic because it's not necessary:

limpid cradleBOT Sep 17, 2024, 2:06 PM

#

nonspicyburrito#0

Playground Link

Preview:```ts
interface Book {
id: number
name: string
pages: number
created_at: string
}

type ArgsOf<T> = {
[K in keyof T]: [key: K, value: T[K]]
}[keyof T]

type BookArgs = ArgsOf<Book>

type FnThatUsesAllBookKeys = (
...args: BookArgs
) => void

type PartialBook = Pick<Book, "name" | "pages">
...```

static dragon Sep 17, 2024, 2:07 PM

#

Although I suppose it depends on what you are doing in the function implementation.

quiet flint Sep 17, 2024, 2:07 PM

#

using a generic makes it possible to misalign the 2 args from a union

static dragon Sep 17, 2024, 2:08 PM

#

Ah yeah forgot about that.

#

Generic used in this way is not safe, you would need to wrap it in U2I.

potent basalt Sep 17, 2024, 2:21 PM

#

limpid cradle

I ended up going with this solution in the end

#

the mapped type implementation is interesting though! I haven't thought about using that for parameters

static dragon Sep 17, 2024, 2:23 PM

#

quiet flint using a generic makes it possible to misalign the 2 args from a union

Keep in mind of this issue, I'd suggest going with union instead.

potent basalt Sep 17, 2024, 2:38 PM

#

static dragon Keep in mind of this issue, I'd suggest going with union instead.

which of the playgrounds are you referring to specifically? the one you posted with mapped type?

quiet flint Sep 17, 2024, 2:43 PM

#

yes, though it's not using the mapped type directly, it's using the mapped type to generate a discriminated union

potent basalt Sep 17, 2024, 2:48 PM

#

yeah

#

that.. somewhat feels like a hacky way to create generics? 😛

static dragon Sep 17, 2024, 2:50 PM

#

potent basalt that.. somewhat feels like a hacky way to create generics? 😛

Nope, the generic solution is actually wrong and unsafe.

potent basalt Sep 17, 2024, 2:50 PM

#

how so?

static dragon Sep 17, 2024, 2:51 PM

#

interface Book {
    id: number
    name: string
}

declare const fn: <Key extends keyof Book>(key: Key, value: Book[Key]) => void

fn<'id' | 'name'>('id', 'not a number')

#

This passes type check.

quiet flint Sep 17, 2024, 2:51 PM

#

function twoOfSameType<T extends "a" | "b">(a: T, b: T) {}
twoOfSameType("a", "b"); // not of same type
// ^? - twoOfSameType<"a" | "b">

static dragon Sep 17, 2024, 2:51 PM

#

The DU solution will actually prevent you from this.

potent basalt Sep 17, 2024, 2:52 PM

#

...huh, I see

quiet flint Sep 17, 2024, 2:53 PM

#

it's [A | B, A | B] vs [A, A] | [B, B]

#

a plain generic turns into the former

static dragon Sep 17, 2024, 2:53 PM

#

Practically, this is rarely ever an issue so it's mostly fine. The bigger issue of the generic solution is that inside your function implementation, you won't be able to narrow key at all, unlike DU which you can.

#

But that depends on what you are actually doing inside your implementation, which may or may not be relevant.

potent basalt Sep 17, 2024, 2:54 PM

#

I think that's something I've run into in the past with the generic implementation, so that's a very interesting point

static dragon Sep 17, 2024, 2:55 PM

#

static dragon But that depends on what you are actually doing inside your implementation, whic...

With the generic solution for example, you won't be able to narrow:

limpid cradleBOT Sep 17, 2024, 2:55 PM

#

interface Book {
    id: number
    name: string
}

const fn = <Key extends keyof Book>(key: Key, value: Book[Key]) => {
    if (key === 'id') {
        value
//         ^? - (parameter) value: Book[Key]
    } else {
        key
//         ^? - (parameter) key: Key extends keyof Book
        value
//         ^? - (parameter) value: Book[Key]
    }
}

static dragon Sep 17, 2024, 2:56 PM

#

With DU solution:

limpid cradleBOT Sep 17, 2024, 2:56 PM

#

interface Book {
    id: number
    name: string
}

const fn = (...[key, value]: ['id', number] | ['name', string]) => {
    if (key === 'id') {
        value
//         ^? - (parameter) value: number
    } else {
        key
//         ^? - (parameter) key: "name"
        value
//         ^? - (parameter) value: string
    }
}

potent basalt Sep 17, 2024, 2:56 PM

#

makes sense!

#

thank you so much! I hadn't thought about the lack of safety with the generic implementation, even if it's not a problem in most cases in practice

#

being able to narrow the key/value pair inside the implementation will also be useful, though not something I've done often

#Function type assignability with generic parameters