Strongly Typed Function Parameters in TypeScript

By the end of this page, you will understand why using Function is too broad in TypeScript, how to replace it with a typed function signature, and how TypeScript checks callback parameter types at compile time. You will also see common callback patterns, real-world usage, and how this compares to delegates in languages like C#.

In TypeScript, the type Function means some callable value, but it does not describe the function's parameter types or return type in a useful way.

That is why this is unsafe:

save(callback: Function): void

It tells TypeScript only that callback is a function. It does not tell TypeScript:

• how many arguments the function expects
• what types those arguments should be
• what the function returns

If you want type safety, you should use a function type signature.

For your example, the callback should accept one number and return void:

save(callback: (result: number) => void): void

Now TypeScript knows the exact shape of the callback. If you try to pass a function that expects a string instead of a number, TypeScript can report an error.

This matters because callbacks are everywhere in real programs:

Think of Function as writing "some tool" on a box label.

That tells you the box contains a tool, but not whether it is:

• a hammer
• a screwdriver
• a wrench

A typed function signature is like labeling the box with exact instructions:

• takes one number
• returns nothing

Now anyone using the box knows exactly what fits.

So:

• Function = "this is a function somehow"
• (result: number) => void = "this function must take one number and return nothing"

The second label is what gives you safety.

Core syntax

Use a function type instead of Function:

(result: number) => void

This means:

• the function takes one parameter named result
• that parameter must be a number
• the function returns void

Your example, typed safely

class Foo {
  save(callback: (result: number) => void): void {
    const result = 42;
    callback(result);
  }
}

const foo = new Foo();

const goodCallback = (result: number): void => {
  console.log(result);
};

foo.save(goodCallback);

Consider this code:

class Foo {
  save(callback: (result: number) => void): void {
    const result = 42;
    callback(result);
  }
}

const foo = new Foo();

const callback = (result: number): void => {
  console.log("Saved value:", result);
};

foo.save(callback);

Step by step:

1. Foo defines a method named save.
2. save expects one argument: a function.
3. That function must match this shape:
   • one parameter
   • parameter type is number
   • return type is void
4. const result = 42; creates a number.

1. API request callbacks

A function may fetch data, then pass the result to a callback:

type UserCallback = (userId: number) => void;

function loadUser(callback: UserCallback): void {
  callback(101);
}

This prevents accidentally writing a callback that expects the wrong type.

2. Event processing

You may define custom event handlers:

type MessageHandler = (message: string) => void;

function onMessage(handler: MessageHandler): void {
  handler("Hello");
}

3. Data transformation

Functions like map use typed callbacks:

In real projects, developers rarely use raw Function unless they truly mean "any function at all." Most of the time, they write exact function signatures.

Common patterns

Guarding callback inputs

type SaveCallback = (result: number) => void;

function saveValue(value: number, callback: SaveCallback): void {
  if (value < 0) {
    return;
  }

  callback(value);
}

The guard clause handles invalid state early, and the callback stays well typed.

Reusing callback types

type ErrorHandler = (message: string) => void;
type SuccessHandler = (id: number) => void;

1. Using Function instead of a real signature

Broken:

function save(callback: Function): void {
  callback(42);
}

Why it is a problem:

• Function is too generic
• parameter and return types are lost

Better:

function save(callback: (result: number) => void): void {
  callback(42);
}

2. Forgetting the return type

Sometimes beginners type only the parameter list mentally, but not the full function shape.

Correct form:

(value: number) => void

Not just:

(value: )

Function vs typed function signature

// Avoid
callback: Function

// Prefer
callback: (value: number) => void

Common patterns

type Callback = (value: number) => void;

type Formatter = (value: number) => string;

type Validator = (text: string) => boolean;

Class method example

class Foo {
  save(callback: (result: number) => void): void {
     result = ;
    (result);
  }
}

Is Function bad in TypeScript?

Not always, but it is usually too broad for callback parameters. It loses important information about arguments and return values.

How do I type a callback function in TypeScript?

Use a function signature such as:

(callback: (value: number) => void)

Can I create a reusable callback type?

Yes. Use a type alias:

type SaveCallback = (value: number) => void;

Is there a TypeScript equivalent to a C# delegate?

Yes. A typed function signature, often stored in a type alias, is the closest equivalent.

Should I use a type alias or an interface for function types?

Either works. For simple callbacks, many developers prefer type because it is shorter and clearer.

Why did my wrong callback still compile?

It may be because you used Function, or because your TypeScript configuration is not strict enough. Exact behavior can vary with compiler settings.

• Type aliases — useful for naming and reusing callback function signatures.
• Interfaces — can also describe callable shapes using call signatures.
• Arrow functions — commonly used when defining inline callbacks.
• Function return types — important when callbacks return values instead of void.
• Type inference — TypeScript can often infer callback parameter and return types.
• Strict mode — stronger compiler checks make callback typing more reliable.
• Generics — useful when callback parameter types depend on other types.
• Event handlers — a common real-world use of strongly typed function parameters.