Type inference fails for function accepting function with object argument

[staeke]

TypeScript Version: 3.7.x-dev.201xxxxx
3.7.4

Search Terms:
inference

function func(arg: {foo:1, bar: 1}) {}

// 1. Fails
giveMeAFunc(func)
// 2. Succeeds
giveMeAFunc<{foo: 1, bar: 1}, typeof func>(func)

function giveMeAFunc<TArg extends {foo:1}, TFn extends (t:TArg) => void>(fn:TFn) {}

Expected behavior:
I'd expect TS to infer the type arguments in case 1 (to be case 2)

Actual behavior:
Fails with message that bar is a missing property

Playground Link:
Couldn't find a "Share" button

Related Issues:
not really

[staeke]

I should probably add another comment:

Why not just type giveMeAFunc like this then?

function giveMeAFunc<TArg extends {foo:1}>(fn:(t:TArg) => void) {}

While that works, I want to use the exact type of the function for parts of the return type in my real world example. Something like

function giveMeAFunc<TArg extends {foo:1}, TFn extends (t:TArg) => void>(fn:TFn):TFn {
  return null as any
}

[staeke]

That said - I realized that this works

function giveMeAFunc<TArg extends {foo:1}, TFn>(fn:TFn & ((t:TArg) => void)):TFn {
  return null as any
}

Why? And also, isn't the original issue still valid?

[RyanCavanaugh]

See #30134.

Ultimately you have "too many" type parameters and this is not the best way to write the function declaration.

[staeke]

@RyanCavanaugh ok, thanks. Is there a better way, that allows me to:

• keep the type of the passed function for return type (names of arguments for instance)
• require that the function is accepting one object argument with a property foo

?

[RyanCavanaugh]

Not really, since what you're describing is both an upper and lower bound on the function. The intersection you have is the best option.