Function should be assignable to (...args: any[]) => any

[pelotom]

Obviously all functions have type Function. And likewise all functions can be given the type

type AnyFunc = (...args: any[]) => any;

AFAIK, there is nothing one can do with something of type Function that cannot be done with something of type AnyFunc and vice versa. However they are not equivalently assignable:

(f: AnyFunc): Function => f;
(f: Function): AnyFunc => f;
//                        ^
// Type 'Function' is not assignable to type 'AnyFunc'.
//   Type 'Function' provides no match for the signature '(...args: any[]): any'.

If I edit lib.d.ts to add a callable signature to Function:

interface Function {
  (...argArray: any[]): any;
  //...
}

it seems to "fix" this issue; is there any reason not to make this change for real?

[mhegazy]

The original intention of Function is to not be callable. in other words, Function to function types should be like unknown to other types, but not callable. we have since relaxed this restriction giving Function a callable behavior in the compiler through special casing. We have talked about making this a --noImplicitAny error since, it is really unsafe to call Functions.

[aleclarson]

@mhegazy What's the benefit of such behavior, rather than treating Function as identical to (...args: any[]) => any? 🤔

I have a similar question about object and { [key: keyof any]: any } not being treated as identical.

[Pictor13]

I'm using Function in JSDoc, but when passing it as a parameter to a function expecting (...args: any[]) => any I'm getting the same problem.

Having CallableFunction helps with TypeScript, but I was wondering if there is a fix (or workaround) to avoid receiving the type error (from VSCode interpreter) when working with only JavaScript.
Apart for // @ts-ignore of course.

[aral]

For folks working in JavaScript:

/**
  @typedef {(...args: any[]) => any} JavaScriptFunction
*/

Then just use JavaScriptFunction where you expect a JavaScript function.

[mkantor]

@aral typeof x === "function" guards narrow to Function, so it can be hard to avoid entirely.

[gregor-dissemond]

Also note that Function is wider than (...args: any[]) => any or its type-safe and uncallable alternative (...args: never) => unknown. A common example for this are classes - they are assignable to Function but not to (...args: never) => unknown, instead you can assign them to new (...args: never) => unknown. Perhaps a union of the two of them would be a valid narrowing of values with typeof x === "function".

Even worse: there are values with typeof x === "object" that are assignable to Function, e.g. the following does not yield an error (with TS 5.8.3):

const x: Function = {
  apply() {},
  bind() {},
  call() {},
  caller() {},
  toString() {
    return "";
  },
  arguments: [],
  length: 0,
  name: "",
  prototype: Function,
  [Symbol.hasInstance]() {
    return true;
  },
};

Perhaps one wants to change this behavior and reserve Function only for values with typeof x === "function". But as long as the differentiation between (...args: never) => unknown and new (...args: never) => unknown is kept (and I think this is wanted behavior), one should not be able to assign Function to (...args: never) => unknown (or as originally phrased to (...args: any[]) => any).