Type Cast or Assertions on the FunctionDeclaration

[Jack-Works]

Search Terms

function declaration type cast assertions

Suggestion

A new syntax to cast or assert function declaration as a type T.

function MyFunction() {} as React.ComponentType
// same as
const MyFunction = (function MyFunction() {}) as React.ComponentType

function F2() {} asserts FunctionWithAdditionalProperty
// same as
function F2() {}
function _assert_(f: FunctionWithAdditionalProperty) {}
_assert_(F2)

Use Cases

In some cases, we want to type-check a function to obey a type constraint but it is not easy to do on the FunctionDeclaration statement.

Examples

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[RebeccaStevens]

My proposed syntax for this is as follows:

// Given some type:
type F = <T>(param: T) => string;

// New syntax for casting:
function foo1(param) { /* ... */ } as F
<F>function foo2(param) { /* ... */ }

// New syntax for declarations:
function foo3: F (param) { /* ... */ }
declare function foo4: F;

Note: declare function foo4: F differs from declare const foo4: F as the former should work in the following case while the later fails.

declare const foo4: F;	// <-- Cannot redeclare block-scoped variable 'foo4'. ts(2451)
declare namespace foo4 { /* ... */ }

[jekh]

Is this a duplicate of #22063? I'm wondering if we can consolidate these these issues to focus attention on them. I would love to see the ability to type function declarations, no matter what syntax is ultimately chosen.

[Jack-Works]

Is this a duplicate of #22063? I'm wondering if we can consolidate these these issues to focus attention on them. I would love to see the ability to type function declarations, no matter what syntax is ultimately chosen.

Yes I guess?