partial function with generic lost the type constraint

[111fanyj]

🔎 Search Terms

generic
partial function with generic lose the type constraint

🕗 Version & Regression Information

• This is a crash
• This changed between versions nightly__ and 4.x___
• This changed in commit or PR _______
• This is the behavior in every version I tried, and I reviewed the FAQ for entries about ___ generic, lose type______
• I was unable to test this on prior versions because the version lower than 4.0 do not support tailargs___

⏯ Playground Link

https://www.typescriptlang.org/play?ts=5.4.0-dev.20240107#code/PTAEFsEsDtPBDANqATgUwA4oPYBMCuAxmgFAkAuAnhmqAIIoqgC8qa8u20ilo80lANoBdMgDN80QuUhdQGeChlIAwkkQAeACqg0AD3JpouAM71GAGlABVXQaOnzKKwCUAfAAoSoUGIBcoB4AdCGKAOYmAYIhQVpWMdbCAJQsbqAuFt6gMQAW7LgMEQFaJCkA3lno5Pgo0IEx5PCQiIWRNinMaWLBIXkcrfEhjc2tSSQAvmSEXCbkEPCEOTBozBU+WJDEAQDMAAyZPvBhaH4AjLsT4pLSsnXQ+OAqOfzH2naGxmYuaNMouBqzFAwMJWe7gABGaBQbk8oGw4IAVn44qAANZoSgBdGUbBiUAo3BoRCNAJgyEoJJrHw+Ko1OrwhGCbHCADUhOJ8EuEikMjkYKeLzQpze+g+jm+v3+gOBoIe5JhHjRGKxGNx+KsDORFnZJNAZKhlKy1NptThiKZGNZOs5kxI02gs1AhkdrH5z2gxw8CEWy1AVgA5Ec0P6rOcxiQQKAAALkEwAWn0NGkCcY2BQdpmc2d5FOLD1DwFHrQXoWS2gaAsgZD5z94YzDrm3rLaAAcgX3cdWAolJBVOoPG7BVYm8tw5GTDlsPhELhQJBQCY0LR4LpU0w8uhQAB+euOwynVgj8ttx4d4tViwAJl2YyAA

💻 Code

// minimal reproduce

type Arr = readonly any[]

function partialCall<T extends Arr, U extends Arr, R>(
  f: (...args: [...T, ...U]) => R,
  ...headArgs: T
) {
  return (...tailArgs: U) => f(...headArgs, ...tailArgs)
}

const machine={
  price: 30,
  age:10
}

function numChange<T extends Record<string, number>>( obj:T, key: keyof T, delta: number){
     return obj[key]+delta
}

const test = numChange(machine , 'age', 10)

// @ts-expect-error
const test1 = numChange(machine,'a',10 ,)


const machineNumChange= partialCall(numChange, machine)

// should i see a error here ?
const te1= machineNumChange('a',20)

🙁 Actual behavior

I'm using a partial function with passing another generic function , the returned function loses the type restrictions on its parameters.

🙂 Expected behavior

the returned function have the type restrictions on its parameters

Additional information about the issue

No response

[Andarist]

This would require changes to how inferences from generic signatures can be merged into the inference context. The problematic bit is that an inference candidate in the context already exists for T. U appears only in that generic signature - at a contravariant position. So maybe the inferred result from the generic signature could be kept around and then based on some rules instantiated with existing inferences.

A different example that could also work (when the inference of outer T doesn't depend on the inner T):

type Arr = readonly any[];

function partialCall<T extends Arr, U extends Arr, R>(
  f: (...args: [...T, ...U]) => R,
  ...headArgs: T
) {
  return (...tailArgs: U) => f(...headArgs, ...tailArgs);
}

function fn<T extends Record<string, number>>(
  delta: number,
  key: keyof T,
  obj: T,
) {
  return obj[key] + delta;
}

// actual: const result: (...tailArgs: Arr) => number
// expected: const result: <T extends Record<string, number>>(key: keyof T, obj: T) => number
const result = partialCall(fn, 10);

And this one, one that doesn't have any dependency between the inner T and U:

type Arr = readonly any[];

function partialCall<T extends Arr, U extends Arr, R>(
  f: (...args: [...T, ...U]) => R,
  ...headArgs: T
) {
  return (...tailArgs: U) => f(...headArgs, ...tailArgs);
}

declare function fn<T extends Record<string, number>>(
  obj: T,
  delta: number,
): void;

// actual: const result: (...tailArgs: Arr) => void
// expected: const result: (delata: number) => void
const result = partialCall(fn, { a: 1 });