How to fix Function expression requires a return type in TypeScript

What this error means

This error is triggered by ESLint, not the TypeScript compiler itself. Specifically, it comes from the `@typescript-eslint/explicit-function-return-type` rule, which enforces explicit return type annotations on functions and function expressions. TypeScript's type inference is generally powerful enough to determine function return types automatically. However, many teams enable this ESLint rule because explicit return types: 1. **Make code more self-documenting**: Readers immediately know what a function returns without inspecting the implementation 2. **Prevent accidental type changes**: If you modify a function's logic and accidentally change the return type, the compiler will catch it 3. **Improve IDE autocomplete**: Explicit types help IDEs provide better suggestions 4. **Ensure consistent codebase style**: All functions follow the same annotation pattern The rule primarily targets function expressions (arrow functions, function expressions assigned to variables) but can be configured to also check function declarations.

Typical symptoms

• ESLint error shown in your IDE with message 'Function expression requires a return type'
• Build fails with ESLint errors when using strict linting configurations
• Error appears on arrow functions assigned to variables or constants
• Error appears on callback functions passed as arguments
• TypeScript compiler succeeds but ESLint validation fails
• CI/CD pipeline fails during lint step despite code working correctly

Common causes

1. ESLint rule @typescript-eslint/explicit-function-return-type is enabled in your configuration
2. Function expression (arrow function or function assigned to variable) lacks explicit return type annotation
3. Strict TypeScript ESLint preset is active (recommended, recommended-type-checked, strict)
4. Team coding standards require explicit return types for all functions
5. Higher-order functions (functions returning functions) without proper type annotations
6. Callback functions passed to methods like map, filter, reduce without return type

How to fix "Function expression requires a return type"

// BEFORE: ESLint error - no return type annotation
const greet = (name: string) => {
  return `Hello, ${name}`;
};

// AFTER: Explicit return type added
const greet = (name: string): string => {
  return `Hello, ${name}`;
};

// Union return type
const getValue = (useDefault: boolean): string | number => {
  return useDefault ? "default" : 42;
};

// Void for functions with no return value
const logMessage = (msg: string): void => {
  console.log(msg);
};

// Promise return type for async functions
const fetchData = async (id: string): Promise<User> => {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
};

// Define function type
type GreetFunction = (name: string) => string;

// BEFORE: Error - function expression needs return type
const greet = (name: string) => {
  return `Hello, ${name}`;
};

// AFTER: Variable has function type annotation
const greet: GreetFunction = (name) => {
  return `Hello, ${name}`;
};

// React event handler example
type ClickHandler = (event: React.MouseEvent<HTMLButtonElement>) => void;

const handleClick: ClickHandler = (event) => {
  event.preventDefault();
  console.log("Clicked!");
};

{
  "rules": {
    "@typescript-eslint/explicit-function-return-type": [
      "error",
      {
        "allowExpressions": true,
        "allowTypedFunctionExpressions": true,
        "allowHigherOrderFunctions": true
      }
    ]
  }
}

{
  "rules": {
    "@typescript-eslint/explicit-function-return-type": "off"
  }
}

// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
const calculateTotal = (items: Item[]) => {
  return items.reduce((sum, item) => sum + item.price, 0);
};

// Public API - explicit return type recommended
export const processUser = (user: User): ProcessedUser => {
  return {
    id: user.id,
    displayName: `${user.firstName} ${user.lastName}`,
    isActive: user.status === "active",
  };
};

// Internal helper - type inference OK
const formatName = (first: string, last: string) => {
  return `${first} ${last}`;
};

Advanced notes

// Without explicit types - may trigger error
const createMultiplier = (factor: number) => {
  return (value: number) => value * factor;
};

// With explicit types - clear and error-free
const createMultiplier = (factor: number): ((value: number) => number) => {
  return (value: number): number => value * factor;
};

// Or use a type alias for clarity
type Multiplier = (value: number) => number;
const createMultiplier = (factor: number): Multiplier => {
  return (value: number): number => value * factor;
};

interface ButtonProps {
  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
  label: string;
}

// Explicit return type matches interface
const Button = ({ onClick, label }: ButtonProps): JSX.Element => {
  return <button onClick={onClick}>{label}</button>;
};

// Explicit return type clarifies generic usage
const firstElement = <T>(arr: T[]): T | undefined => {
  return arr[0];
};

// Complex generic - explicit return type essential
const mapValues = <T, U>(
  obj: Record<string, T>,
  fn: (value: T) => U
): Record<string, U> => {
  const result: Record<string, U> = {};
  for (const key in obj) {
    result[key] = fn(obj[key]);
  }
  return result;
};

// Implicit - returns Promise<number> but not obvious
const fetchCount = async () => {
  const response = await fetch("/api/count");
  return response.json();
};

// Explicit - clearly a Promise
const fetchCount = async (): Promise<number> => {
  const response = await fetch("/api/count");
  return response.json();
};

Frequently asked questions

What does "Function expression requires a return type" mean?

This error is triggered by ESLint, not the TypeScript compiler itself. Specifically, it comes from the @typescript-eslint/explicit-function-return-type rule, which enforces explicit return type annotations on functions and function expressions. TypeScript's type inference is generally powerful enough to determine function return types automatically.

How do I fix "Function expression requires a return type"?

This ESLint error occurs when the @typescript-eslint/explicit-function-return-type rule is enabled and you define a function expression without explicitly annotating its return type. While TypeScript can infer return types, this linting rule enforces explicit annotations for better code clarity and type safety.

What causes "Function expression requires a return type"?

ESLint rule @typescript-eslint/explicit-function-return-type is enabled in your configuration Function expression (arrow function or function assigned to variable) lacks explicit return type annotation Strict TypeScript ESLint preset is active (recommended, recommended-type-checked, strict)

Is the "Function expression requires a return type" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Function lacks ending return statement and return type does not include 'undefined'

  Function lacks ending return statement and return type does not include 'undefined'

  MEDIUM

• 'forceConsistentCasingInFileNames' is not set, but 'paths' config is used

  How to fix 'forceConsistentCasingInFileNames' is not set, but 'paths' config is used

  MEDIUM

• A function whose declared type is neither 'void' nor 'any' must return a value

  A function whose declared type is neither 'void' nor 'any' must return a value

  MEDIUM

• src/index.ts is not under 'rootDir'

  How to fix 'file is not under rootDir' error in TypeScript

  MEDIUM

• Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.

  How to fix "Cannot find name 'process'" in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• 📖
  typescriptlang.org - functions(Official Docs)
• 🔗
  typescriptlang.org - tsconfig