eslint-plugin-functional

The plugin organizes its rules into several thematic categories to enforce functional programming paradigms. You can enable these rules by using the corresponding configuration presets in your ESLint configuration:

• Currying: Rules related to functional parameter patterns.
• No Exceptions: Rules to disallow throwing exceptions and try-catch patterns.
• No Mutations: Rules to enforce data immutability and disallow mutable variables.
• No Other Paradigms: Rules to restrict object-oriented patterns like classes and this access.
• No Statements: Rules to disallow imperative control flow like loops and conditional statements.
• Stylistic: Rules for functional code style preferences.

The overrides option allows you to apply different settings based on where a type is declared (file, library, or package). This is useful for relaxing rules for 3rd party libraries. Only the first matching override is used.

Each override can:

• match: Define a specifier (file path, package name, or pattern).
• options: Provide new configuration options.
• inherit: Determine if root options should be merged (defaults to true).
• disable: Completely disable the rule for the matching node if true.

When using functional/no-class-inheritance, you should avoid using the extends keyword. Instead, use composition by nesting instances of other classes within your class to share behavior or data.

/* eslint functional/no-class-inheritance: "error" */

// ✅ Correct: Using composition instead of inheritance
class Animal {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}

class Dog {
  constructor(name, age) {
    this.animal = new Animal(name, age);
  }

  get ageInDogYears() {
    return 7 * this.animal.age;
  }
}

const dogA = new Dog("Jasper", 2);
console.log(`${dogA.animal.name} is ${dogA.ageInDogYears} in dog years.`);

By default, let is disallowed everywhere. If you set allowInForLoopInit: true, the rule will permit let declarations specifically within the initializer of a standard for loop (e.g., for (let i = 0; ...) {}).

Note: This does not allow let in for...of or for...in loops; those must still use const.

/* eslint functional/no-let: ["error", { "allowInForLoopInit": true }] */

// ✅ Correct (allowed with this option)
for (let i = 0; i < array.length; i++) {}

// ❌ Incorrect (still disallowed in for...of)
for (let element of array) {}

The overrides option allows you to apply different rule settings based on the function's type. This is particularly useful for handling 3rd party library types that might not follow your strict functional rules.

Note: This requires type information.

Each override object contains:

• match: An array of specifiers to match the function type against (can match file, lib, or package).
• options: The configuration to apply when a match is found.
• inherit: Whether to inherit the root options (defaults to true).
• disable: If true, the rule is completely disabled for matching nodes.

Only the first matching override will be used.

Setting allowReturningBranches: "ifExhaustive" allows conditional statements if they are exhaustive (every case is covered and returns a value). This allows you to use a switch or if/else block as an expression by wrapping it in an IIFE.

Note: This option is currently incompatible with the no-else-return rule; else statements must contain a return statement.

const x = (() => {
  switch (y) {
    case "a":
      return 1;
    case "b":
      return 2;
    default:
      return 0;
  }
})();

In functional programming, parameters should be known and explicit. This rule prevents patterns that allow an unknown number of arguments, which makes currying difficult or impossible.

Disallowed Patterns

• Using the arguments keyword to access passed arguments.
• Using rest parameters (...args) to capture an arbitrary number of arguments.

Allowed Pattern

• Passing an explicit collection (like an array) as a single parameter.

Example

Incorrect:

/* eslint functional/functional-parameters: "error" */
function add() {
  return arguments.reduce((sum, number) => sum + number, 0);
}

function add(...numbers) {
  return numbers.reduce((sum, number) => sum + number, 0);
}

Correct:

/* eslint functional/functional-parameters: "error" */
function add(numbers) {
  return numbers.reduce((sum, number) => sum + number, 0);
}

By default (false), the rule flags all types that are not explicitly annotated. If an external dependency uses mutable types in its callbacks, you can set ignoreInferredTypes: true to allow the rule to skip values where the type is inferred by TypeScript, avoiding the need to manually annotate parameters that match external interfaces.

/* eslint functional/prefer-immutable-types: ["error", { "ignoreInferredTypes": true }] */
import { acceptsCallback } from "external-dependency";

// The 'options' type is inferred, so it is ignored
acceptsCallback((options) => {});