Functional Programming - Immutability, Pure Functions & Higher-Order Functions

A programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. It emphasizes immutability, pure functions, and declarative code.

Immutability means that data, once created, cannot be changed. Instead of modifying existing data, new data is created with the desired changes, leaving the original data untouched.

It prevents unexpected side effects, makes code easier to reason about, simplifies concurrent programming by eliminating race conditions, and enhances predictability and testability.

Instead of arr.push(4) (mutates arr), use const newArr = [...arr, 4]; or const newArr = arr.concat(4);. For objects, const newObj = { ...oldObj, key: 'newValue' }; creates a new object without modifying oldObj.

A function that satisfies two conditions:
1. Deterministic: Given the same input, it will always return the same output.
2. No Side Effects: It produces no observable changes to the system outside its local scope (e.g., modifying global state, I/O operations, changing arguments).

def add(a, b):
    return a + b

This function always returns the same output for the same inputs and has no side effects.

let total = 0;
function addToTotal(num) {
    total += num; // Side effect: modifies external state
    return total;
}

This is impure because it modifies a variable outside its scope (total) and its output depends on the external total's current value, not just its inputs.

An expression is referentially transparent if it can be replaced with its corresponding value without changing the program's behavior. Pure functions are inherently referentially transparent.