Are strongly-typed functions as parameters possible in TypeScript?

Yes! You can pass strongly typed functions as parameters in TypeScript. You simply define a function type (or inline the signature) and use it as the type for the parameter. This ensures that your callback or function parameter is type-checked—providing IntelliSense, error checking, and clarity throughout your code.

1. Defining a Function Type

You can define a function type using either a type alias or an interface. For example:

type StringToNumberFunc = (input: string) => number;

function doSomethingWithCallback(cb: StringToNumberFunc): void {
  const result: number = cb("Hello");
  console.log(result);
}

• type StringToNumberFunc: Declares a function type taking a string and returning a number.
• cb: StringToNumberFunc: Means cb must be a function matching (input: string) => number.

Usage:

function lengthCalculator(str: string): number {
  return str.length;
}

doSomethingWithCallback(lengthCalculator); // OK
doSomethingWithCallback((x) => x.charCodeAt(0)); // Also OK

// doSomethingWithCallback((x: number) => x + 1);
// Error: Parameter type doesn't match the signature `(string) => number`

Here, TypeScript enforces that any function passed in must accept a string and return a number.

2. Inline Function Parameter Types

You can also do it inline without a type alias:

function doSomething(cb: (arg: string) => number): void {
  console.log(cb("Hi")); 
}

• The parameter cb must be a function that takes a string and returns a number.

3. Interfaces for Function Types

You can similarly define an interface for function types:

interface StringToBoolean {
  (input: string): boolean;
}

function validate(str: string, checker: StringToBoolean) {
  return checker(str);
}

This is mostly a stylistic preference vs. using a type alias, but sometimes you might want to expand or merge interfaces.

4. Benefits of Strongly Typed Function Parameters

1. Type Safety: TypeScript catches errors at compile time if you pass a callback of the wrong signature.
2. Better IntelliSense: Editors can provide argument suggestions and return type info.
3. Refactor-Friendly: If you change the function signature, TypeScript will highlight all places that break.

5. Summary

Yes, strongly typed function parameters are not only possible but are a core feature of TypeScript. Whether you define a type alias, an interface, or do it inline, TypeScript ensures your callback’s input and output match the expected signature—yielding safer, more maintainable code.

Bonus: If you’re looking to sharpen your JavaScript (and by extension, TypeScript) fundamentals, consider the Grokking JavaScript Fundamentals course by DesignGurus.io. It dives deep into closures, prototypes, async patterns, and more—key building blocks for effectively working with TypeScript’s advanced type features.