fp-higher-order-functions

Higher-Order Functions and Functional Patterns

Higher-order functions are functions that take other functions as arguments or return functions as results. They enable powerful abstractions, code reuse, and declarative programming styles. The classic trio of map, filter, and reduce form the foundation of functional data transformation.

Understanding Higher-Order Functions

A higher-order function is any function that does at least one of the following:

1. Accepts functions as parameters
2. Returns a function as its result

This enables composition, abstraction, and powerful declarative patterns.

JavaScript: Basic Higher-Order Functions

// Function that takes a function as argument
function applyOperation(x, y, operation) {
  return operation(x, y);
}

const sum = applyOperation(5, 3, (a, b) => a + b);        // 8
const product = applyOperation(5, 3, (a, b) => a * b);    // 15

// Function that returns a function
function createMultiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log(double(5));   // 10
console.log(triple(5));   // 15

// Practical example: Event handler creator
function createClickHandler(message) {
  return function(event) {
    console.log(message, event.target);
  };
}

const submitHandler = createClickHandler('Form submitted from:');
const cancelHandler = createClickHandler('Cancelled from:');

// Higher-order function for timing
function measureTime(fn) {
  return function(...args) {
    const start = performance.now();
    const result = fn(...args);
    const end = performance.now();
    console.log(`Execution time: ${end - start}ms`);
    return result;
  };
}

function slowCalculation(n) {
  let sum = 0;
  for (let i = 0; i < n; i++) {
    sum += i;
  }
  return sum;
}

const timedCalculation = measureTime(slowCalculation);
timedCalculation(1000000);  // Logs execution time

Map: Transforming Collections