Functional Programming Concepts Cheat Sheet

Pure functions, immutability, higher-order functions, function composition, and currying — the core ideas behind functional programming, explained with runnable JavaScript examples.

2 PagesIntermediateApr 8, 2026

Pure Functions & Immutability

Contrasting impure, stateful code with pure functions and immutable updates.

javascript

// Impure: relies on and mutates external statelet total = 0;function addImpure(x) { total += x; return total; }// Pure: same input always produces same output, no side effectsfunction add(a, b) { return a + b; }// Immutable update instead of mutationconst original = { name: "Ada", age: 30 };const updated = { ...original, age: 31 };   // original is untouchedconst list = [1, 2, 3];const appended = [...list, 4];              // new array, list unchanged

Higher-Order Functions

Using map, filter, and reduce instead of manual loops.

javascript

const nums = [1, 2, 3, 4, 5];const doubled = nums.map(n => n * 2);          // [2, 4, 6, 8, 10]const evens = nums.filter(n => n % 2 === 0);   // [2, 4]const sum = nums.reduce((acc, n) => acc + n, 0); // 15// A function that returns a functionconst multiplyBy = factor => n => n * factor;const triple = multiplyBy(3);triple(7); // 21

Composition & Currying

Combining small functions and partially applying arguments.

javascript

// compose: right-to-left function compositionconst compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);const addOne = n => n + 1;const double = n => n * 2;const addThenDouble = compose(double, addOne);addThenDouble(3); // (3 + 1) * 2 = 8// Currying: transform f(a, b, c) into f(a)(b)(c)const curry = fn => (...args) =>  args.length >= fn.length    ? fn(...args)    : (...more) => curry(fn)(...args, ...more);const add3 = curry((a, b, c) => a + b + c);add3(1)(2)(3); // 6add3(1, 2)(3); // 6

Core FP Concepts

Key vocabulary used throughout functional programming.

Pure Function- Given the same input, always returns the same output and produces no observable side effects
Immutability- Data cannot be changed after creation; updates create new copies instead of mutating in place
First-Class Functions- Functions can be assigned to variables, passed as arguments, and returned from other functions
Higher-Order Function- A function that takes one or more functions as arguments and/or returns a function
Referential Transparency- An expression can be replaced with its resulting value without changing the program's behavior
Function Composition- Combining simple functions to build more complex ones, e.g. compose(f, g)(x) equals f(g(x))
Currying- Transforming a function of N arguments into a chain of N functions that each take one argument
Closures- A function that retains access to variables from its enclosing scope even after that scope has returned
Recursion- Solving a problem by having a function call itself on a smaller subproblem, often replacing loops
Monad- A pattern that wraps a value and defines how to chain operations over it, e.g. Promise, Maybe/Option

Pro Tip

Favor .map/.filter/.reduce chains over manual for-loops with mutable accumulators — they make intent explicit and are easier to test in isolation, but stop chaining once a pipeline gets so long that debugging intermediate values becomes painful.

Was this cheat sheet helpful?

Graph Algorithms Cheat Sheet

Concurrency & Parallelism Concepts Cheat Sheet

Explore Topics

#FunctionalProgrammingConcepts#FunctionalProgrammingConceptsCheatSheet#Programming#Intermediate#PureFunctionsImmutability#HigherOrderFunctions#CompositionCurrying#CoreFPConcepts#Functions#CheatSheet#SkillVeris

Sri Hayavadhana Info-Tech

Professional Web Designing Services