Core FP Principles

• Immutability: Data cannot be modified after creation; return new copies instead
• Pure Functions: Same input always produces same output; no side effects
• Declarative Style: Express what to compute, not how (map/filter vs loops)
• Function Composition: Build complex operations from simple functions
• First-Class Functions: Functions as values - pass, return, store

Imperative to Functional Transformations

1. Replace Loops with Map/Filter/Reduce

// Before (Imperative)
const results = [];
for (let i = 0; i < items.length; i++) {
  if (items[i].active) {
    results.push(items[i].name.toUpperCase());
  }
}

// After (Functional)
const results = items
  .filter(item => item.active)
  .map(item => item.name.toUpperCase());

2. Extract Pure Functions

// Before (Impure - side effects)
let total = 0;
function addToTotal(value) {
  total += value;  // Mutates external state
  return total;
}

// After (Pure)
function add(a, b) {
  return a + b;  // No side effects
}
const total = items.reduce(add, 0);

3. Higher-Order Functions (HOFs) Functions that take or return functions:

// HOF that returns a function
const multiplyBy = (factor) => (number) => number * factor;
const double = multiplyBy(2);
const triple = multiplyBy(3);

// HOF that takes a function
const applyOperation = (operation, value) => operation(value);

4. Function Composition Combine simple functions into complex ones:

// Individual functions
const trim = (str) => str.trim();
const lowercase = (str) => str.toLowerCase();
const removeSpaces = (str) => str.replace(/\s+/g, '');

// Compose utility
const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);

// Composed function
const normalize = compose(removeSpaces, lowercase, trim);

5. Currying Transform multi-argument function into single-argument sequence:

// Before
const add = (a, b, c) => a + b + c;

// After (Curried)
const curriedAdd = (a) => (b) => (c) => a + b + c;
const add5 = curriedAdd(5);
const add5And10 = add5(10);
add5And10(3);  // 18

6. Eliminate Mutation

// Before (Mutation)
const user = { name: 'Alice', age: 30 };
user.age = 31;  // Mutates object

// After (Immutable)
const updatedUser = { ...user, age: 31 };  // New object

7. Replace Null with Maybe/Option Monad

// Before (Null checks)
function getUserEmail(user) {
  if (user && user.profile && user.profile.email) {
    return user.profile.email;
  }
  return null;
}

// After (Functional approach)
const Maybe = (value) => ({
  map: (fn) => value ? Maybe(fn(value)) : Maybe(null),
  getOrElse: (defaultValue) => value || defaultValue
});

const getUserEmail = (user) =>
  Maybe(user)
    .map(u => u.profile)
    .map(p => p.email)
    .getOrElse('no-email@example.com');

8. Separate Side Effects from Pure Logic

// Before (Mixed)
function processOrder(order) {
  const total = calculateTotal(order);  // Pure
  saveToDatabase(order);  // Side effect
  sendEmail(order.customer);  // Side effect
  return total;
}

// After (Separated)
function calculateOrderTotal(order) {  // Pure
  return order.items.reduce((sum, item) => sum + item.price, 0);
}

function performOrderEffects(order) {  // Side effects isolated
  return Promise.all([
    saveToDatabase(order),
    sendEmail(order.customer)
  ]);
}

FP-Specific Code Smells

• Mutation: Modifying variables/objects in place
• Side Effects in Pure Functions: I/O, logging, state changes in computation
• Imperative Loops: Using for/while instead of map/filter/reduce
• Nested Conditionals: Deep if-else instead of pattern matching/guards
• Null/Undefined Checks: Manual null handling instead of Maybe/Option
• Shared Mutable State: Global variables accessed by multiple functions
• Object-Oriented Patterns in FP: Classes with methods instead of functions with data

Benefits of Functional Refactoring

• Testability: Pure functions easy to test (no mocks, no setup)
• Predictability: Same input always gives same output
• Parallelism: No shared state enables safe concurrent execution
• Debugging: No hidden state changes; easier to reason about
• Reusability: Composable functions more reusable than methods

Code Smells Detection