Academy — Sanjib Sikder

The Core Claim

Functional programming makes one strong claim: most bugs come from state that changes in ways you didn't expect. If you eliminate mutation — make data permanently immutable, make functions produce new values instead of changing existing ones — an entire category of bugs becomes structurally impossible.

This is not a philosophy. It is an engineering tradeoff with measurable consequences.

JavaScript

Ctrl+Enter to run

// The problem with mutation — action at a distance
const students = [
  { name: "Rahul",  marks: 82 },
  { name: "Priya",  marks: 91 },
  { name: "Arjun",  marks: 49 },
];

// This function looks innocent
function topStudent(list) {
return list.sort((a, b) => b.marks - a.marks)[0]; // ← sort mutates!
}

console.log("Before:", students.map(s => s.name));
const top = topStudent(students);
console.log("Top:", top.name);
console.log("After:", students.map(s => s.name)); // original array is now sorted!

// The caller had no idea their data was being changed.
// This is action at a distance — the hardest kind of bug to find.

Array.sort mutates in place. The function accepted data and silently rearranged it. The caller is now working with a different array than the one they passed in — and they have no way to know.

Pure Functions — The Foundation

A pure function has two properties: given the same inputs it always returns the same output, and it produces no side effects. No mutation, no network calls, no logging, no modifying variables outside its scope.

JavaScript

Ctrl+Enter to run

// Impure — depends on external state, has side effects
let callCount = 0;
function impureDouble(n) {
  callCount++;           // side effect — modifies external state
  return n * 2;
}

// Pure — same input, same output, nothing else touched
function double(n) { return n * 2; }
function add(a, b) { return a + b; }
function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
function grade(marks) {
if (marks >= 90) return "A+";
if (marks >= 75) return "A";
if (marks >= 50) return "B";
return "F";
}

// Pure functions are trivially testable
const tests = [
[double(5), 10, "double(5)"],
[add(3, 4), 7, "add(3,4)"],
[clamp(150,0,100), 100, "clamp(150,0,100)"],
[grade(82), "A", "grade(82)"],
[grade(45), "F", "grade(45)"],
];

tests.forEach(([got, expected, label]) => {
const ok = got === expected;
console.log(`${ok ? "✓" : "✗"} ${label} → ${got}`);
});

Pure functions compose, cache, parallelise, and test easily. They are the atomic unit of functional programming.

Immutability — Never Change, Always Create

The functional approach to "changing" data is to produce a new version of it, leaving the original intact:

JavaScript

Ctrl+Enter to run

const student = { name: "Rahul", marks: 82, subject: "Physics" };

// Mutable style — modifies original
// student.marks = 91; ← breaks everything that holds a reference to student

// Immutable style — produce a new object
const updated = { ...student, marks: 91 };

console.log("Original:", student); // unchanged
console.log("Updated: ", updated); // new object

// Same for arrays
const scores = [55, 72, 88, 41, 95];

// Immutable add — produce new array
const withNew = [...scores, 100];

// Immutable remove — produce new array without index 2
const withoutIdx2 = scores.filter((_, i) => i !== 2);

// Immutable update — produce new array with index 1 changed
const withUpdate = scores.map((s, i) => i === 1 ? 99 : s);

console.log("Original:", scores);
console.log("Added: ", withNew);
console.log("Removed: ", withoutIdx2);
console.log("Updated: ", withUpdate);

Every operation produces a new value. The original is never touched. Every function that holds a reference to student or scores continues to see exactly what it had — no surprises.

Function Composition — Building Pipelines

If pure functions are atoms, composition is how you build molecules. The output of one function becomes the input of the next:

JavaScript

Ctrl+Enter to run

// compose: right to left (mathematical order)
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

// pipe: left to right (reading order — usually preferred)
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);

// Small, pure, single-purpose functions
const trim = s => s.trim();
const lowercase = s => s.toLowerCase();
const capitalize = s => s.charAt(0).toUpperCase() + s.slice(1);
const removeExtra = s => s.replace(/\s+/g, " ");

// Composed — reads as a pipeline of transformations
const normalise = pipe(trim, lowercase, removeExtra, capitalize);

const inputs = [
" RAHUL KUMAR ",
"priya singh",
" ARJUN DAS",
];

inputs.forEach(s => console.log(`"${s}" → "${normalise(s)}"`));

// Compose numeric transformations
const clamp = (min, max) => n => Math.max(min, Math.min(max, n));
const round = dp => n => Number(n.toFixed(dp));
const percent = n => n / 100;

const normaliseScore = pipe(
clamp(0, 100),
round(1),
percent,
);

[82, 110, -5, 73.678].forEach(s =>
console.log(`${s} → ${normaliseScore(s)}`)
);

// compose: right to left (mathematical order)
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

// pipe: left to right (reading order — usually preferred)
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);

// Small, pure, single-purpose functions
const trim = s => s.trim();
const lowercase = s => s.toLowerCase();
const capitalize = s => s.charAt(0).toUpperCase() + s.slice(1);
const removeExtra = s => s.replace(/\s+/g, " ");

// Composed — reads as a pipeline of transformations
const normalise = pipe(trim, lowercase, removeExtra, capitalize);

const inputs = [
" RAHUL KUMAR ",
"priya singh",
" ARJUN DAS",
];

inputs.forEach(s => console.log(`"${s}" → "${normalise(s)}"`));

// Compose numeric transformations
const clamp = (min, max) => n => Math.max(min, Math.min(max, n));
const round = dp => n => Number(n.toFixed(dp));
const percent = n => n / 100;

const normaliseScore = pipe(
clamp(0, 100),
round(1),
percent,
);

[82, 110, -5, 73.678].forEach(s =>
console.log(`${s} → ${normaliseScore(s)}`)
);

pipe and compose are trivial to implement but unlock a completely different way of thinking about code. Instead of writing procedures — "do this, then that, then this" — you declare transformations and chain them.

Currying — Functions That Return Functions

A curried function takes its arguments one at a time, returning a new function for each until all arguments are supplied. This enables partial application — fixing some arguments and leaving others open:

JavaScript

Ctrl+Enter to run

// Manual currying
const multiply = a => b => a * b;
const add      = a => b => a + b;
const clamp    = min => max => n => Math.max(min, Math.min(max, n));

// Partial application — fix one argument, get a specialised function
const double = multiply(2);
const triple = multiply(3);
const addTen = add(10);
const clamp0to100 = clamp(0)(100);

console.log([1,2,3,4,5].map(double));
console.log([1,2,3,4,5].map(triple));
console.log([1,2,3,4,5].map(addTen));
console.log([82, 110, -5, 50].map(clamp0to100));

// A general curry utility
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
}
return function(...more) {
return curried.apply(this, args.concat(more));
};
};
}

const curriedAdd = curry((a, b, c) => a + b + c);

console.log(curriedAdd(1)(2)(3)); // fully applied one at a time
console.log(curriedAdd(1, 2)(3)); // partially applied
console.log(curriedAdd(1)(2, 3)); // partially applied
console.log(curriedAdd(1, 2, 3)); // all at once

// Manual currying
const multiply = a => b => a * b;
const add      = a => b => a + b;
const clamp    = min => max => n => Math.max(min, Math.min(max, n));

// Partial application — fix one argument, get a specialised function
const double = multiply(2);
const triple = multiply(3);
const addTen = add(10);
const clamp0to100 = clamp(0)(100);

console.log([1,2,3,4,5].map(double));
console.log([1,2,3,4,5].map(triple));
console.log([1,2,3,4,5].map(addTen));
console.log([82, 110, -5, 50].map(clamp0to100));

// A general curry utility
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
}
return function(...more) {
return curried.apply(this, args.concat(more));
};
};
}

const curriedAdd = curry((a, b, c) => a + b + c);

console.log(curriedAdd(1)(2)(3)); // fully applied one at a time
console.log(curriedAdd(1, 2)(3)); // partially applied
console.log(curriedAdd(1)(2, 3)); // partially applied
console.log(curriedAdd(1, 2, 3)); // all at once

Currying transforms functions from "take all arguments now" to "take arguments whenever you have them". This is what makes functions configurable data — you build a specialised tool by fixing the configuration arguments, then pass the tool wherever a simple callback is expected.

Functors — Mappable Containers

A functor is any container that implements map — a way to transform the value inside without leaving the container. You already know the most common one:

JavaScript

Ctrl+Enter to run

// Array is a functor — map transforms each element, returns a new Array
const doubled = [1, 2, 3].map(x => x * 2);  // [2, 4, 6]

// You can build your own functors
class Box {
constructor(value) { this.value = value; }

// map: apply fn to the value, return a new Box
map(fn) { return new Box(fn(this.value)); }

// fold: escape the box — get the final value
fold(fn) { return fn(this.value); }

toString() { return `Box(${this.value})`; }
}

const result = new Box(5)
.map(x => x * 2) // Box(10)
.map(x => x + 1) // Box(11)
.map(x => x.toFixed(2))// Box("11.00")
.fold(x => x); // "11.00"

console.log(result);

// Why bother? The value never leaves the pipeline —
// you can add safety, logging, async, error handling at the container level
// without touching the transformation functions at all

const safeResult = new Box({ name: "Rahul", marks: 82 })
.map(s => ({ ...s, grade: s.marks >= 75 ? "A" : "B" }))
.map(s => `${s.name}: ${s.marks} [${s.grade}]`)
.fold(x => x);

console.log(safeResult);

// Array is a functor — map transforms each element, returns a new Array
const doubled = [1, 2, 3].map(x => x * 2);  // [2, 4, 6]

// You can build your own functors
class Box {
constructor(value) { this.value = value; }

// map: apply fn to the value, return a new Box
map(fn) { return new Box(fn(this.value)); }

// fold: escape the box — get the final value
fold(fn) { return fn(this.value); }

toString() { return `Box(${this.value})`; }
}

const result = new Box(5)
.map(x => x * 2) // Box(10)
.map(x => x + 1) // Box(11)
.map(x => x.toFixed(2))// Box("11.00")
.fold(x => x); // "11.00"

console.log(result);

// Why bother? The value never leaves the pipeline —
// you can add safety, logging, async, error handling at the container level
// without touching the transformation functions at all

const safeResult = new Box({ name: "Rahul", marks: 82 })
.map(s => ({ ...s, grade: s.marks >= 75 ? "A" : "B" }))
.map(s => `${s.name}: ${s.marks} [${s.grade}]`)
.fold(x => x);

console.log(safeResult);

The Maybe monad is the functional replacement for null checks. It represents a value that may or may not exist and propagates absence automatically — no if (x !== null) scattered everywhere:

JavaScript

Ctrl+Enter to run

class Maybe {
  constructor(value) { this._value = value; }

static of(value) { return new Maybe(value); }
static empty() { return new Maybe(null); }

isNothing() { return this._value === null || this._value === undefined; }

// map: if empty, stay empty; otherwise transform
map(fn) {
return this.isNothing() ? Maybe.empty() : Maybe.of(fn(this._value));
}

// chain: like map but fn returns a Maybe (avoids Maybe(Maybe(x)))
chain(fn) {
return this.isNothing() ? Maybe.empty() : fn(this._value);
}

// getOrElse: escape with a fallback
getOrElse(defaultValue) {
return this.isNothing() ? defaultValue : this._value;
}

toString() {
return this.isNothing() ? "Nothing" : `Just(${JSON.stringify(this._value)})`;
}
}

// Simulated database — some records missing
const db = {
1: { id: 1, name: "Rahul", scores: { physics: 82, maths: 91 } },
2: { id: 2, name: "Priya", scores: null },
3: null,
};

const findStudent = id => Maybe.of(db[id]);
const getScores = s => Maybe.of(s.scores);
const getPhysics = sc => Maybe.of(sc.physics);

// Same pipeline for all three — no null checks anywhere
[1, 2, 3, 99].forEach(id => {
const physicsScore = findStudent(id)
.chain(getScores)
.chain(getPhysics)
.map(score => `${score} marks`)
.getOrElse("No physics score available");

console.log(`Student ${id}: ${physicsScore}`);
});

class Maybe {
  constructor(value) { this._value = value; }

static of(value) { return new Maybe(value); }
static empty() { return new Maybe(null); }

isNothing() { return this._value === null || this._value === undefined; }

// map: if empty, stay empty; otherwise transform
map(fn) {
return this.isNothing() ? Maybe.empty() : Maybe.of(fn(this._value));
}

// chain: like map but fn returns a Maybe (avoids Maybe(Maybe(x)))
chain(fn) {
return this.isNothing() ? Maybe.empty() : fn(this._value);
}

// getOrElse: escape with a fallback
getOrElse(defaultValue) {
return this.isNothing() ? defaultValue : this._value;
}

toString() {
return this.isNothing() ? "Nothing" : `Just(${JSON.stringify(this._value)})`;
}
}

// Simulated database — some records missing
const db = {
1: { id: 1, name: "Rahul", scores: { physics: 82, maths: 91 } },
2: { id: 2, name: "Priya", scores: null },
3: null,
};

const findStudent = id => Maybe.of(db[id]);
const getScores = s => Maybe.of(s.scores);
const getPhysics = sc => Maybe.of(sc.physics);

// Same pipeline for all three — no null checks anywhere
[1, 2, 3, 99].forEach(id => {
const physicsScore = findStudent(id)
.chain(getScores)
.chain(getPhysics)
.map(score => `${score} marks`)
.getOrElse("No physics score available");

console.log(`Student ${id}: ${physicsScore}`);
});

Without Maybe, this code would need four separate null checks. With Maybe, null propagates automatically — the pipeline just short-circuits to Nothing whenever any step produces an absent value. The transformation functions (getScores, getPhysics) never need to know about nullability at all.

Either — Typed Error Handling

Either is a container with two states: Right (success, the happy path) and Left (failure, carries the error). It is the functional equivalent of try/catch — but composable:

JavaScript

Ctrl+Enter to run

class Left {
  constructor(value) { this.value = value; }
  map()           { return this; }          // skip — already failed
  chain()         { return this; }
  fold(f, _)      { return f(this.value); } // use left fn
  toString()      { return `Left(${this.value})`; }
}

class Right {
constructor(value) { this.value = value; }
map(fn) { return new Right(fn(this.value)); }
chain(fn) { return fn(this.value); }
fold(_, g) { return g(this.value); } // use right fn
toString() { return `Right(${JSON.stringify(this.value)})`; }
}

const Either = {
of: value => new Right(value),
left: value => new Left(value),
try: fn => { try { return new Right(fn()); } catch(e) { return new Left(e.message); } },
};

// Validation using Either
const validate = {
name: s => typeof s === "string" && s.trim().length > 0
? Either.of(s.trim())
: Either.left("Name must be a non-empty string"),

marks: n => typeof n === "number" && n >= 0 && n <= 100
? Either.of(n)
: Either.left(`Marks must be 0–100, got ${n}`),
};

function createStudent(name, marks) {
return validate.name(name)
.chain(n => validate.marks(marks)
.map(m => ({ name: n, marks: m, grade: m >= 75 ? "A" : "B" }))
)
.fold(
err => `Error: ${err}`,
student => `Created: ${student.name} [${student.grade}]`,
);
}

console.log(createStudent("Rahul", 82));
console.log(createStudent("Priya", 91));
console.log(createStudent("", 75)); // Left — bad name
console.log(createStudent("Arjun", 150)); // Left — bad marks
console.log(createStudent(null, 70)); // Left — bad name

class Left {
  constructor(value) { this.value = value; }
  map()           { return this; }          // skip — already failed
  chain()         { return this; }
  fold(f, _)      { return f(this.value); } // use left fn
  toString()      { return `Left(${this.value})`; }
}

class Right {
constructor(value) { this.value = value; }
map(fn) { return new Right(fn(this.value)); }
chain(fn) { return fn(this.value); }
fold(_, g) { return g(this.value); } // use right fn
toString() { return `Right(${JSON.stringify(this.value)})`; }
}

const Either = {
of: value => new Right(value),
left: value => new Left(value),
try: fn => { try { return new Right(fn()); } catch(e) { return new Left(e.message); } },
};

// Validation using Either
const validate = {
name: s => typeof s === "string" && s.trim().length > 0
? Either.of(s.trim())
: Either.left("Name must be a non-empty string"),

marks: n => typeof n === "number" && n >= 0 && n <= 100
? Either.of(n)
: Either.left(`Marks must be 0–100, got ${n}`),
};

function createStudent(name, marks) {
return validate.name(name)
.chain(n => validate.marks(marks)
.map(m => ({ name: n, marks: m, grade: m >= 75 ? "A" : "B" }))
)
.fold(
err => `Error: ${err}`,
student => `Created: ${student.name} [${student.grade}]`,
);
}

console.log(createStudent("Rahul", 82));
console.log(createStudent("Priya", 91));
console.log(createStudent("", 75)); // Left — bad name
console.log(createStudent("Arjun", 150)); // Left — bad marks
console.log(createStudent(null, 70)); // Left — bad name

The entire pipeline runs without a single if or try/catch. Errors are values — they flow through the chain the same way successes do, just along the left track.

Transducer — Composition Without Intermediate Arrays

When you chain .filter().map().reduce(), each step creates a full intermediate array. Transducers compose the transformations so the data passes through the entire pipeline in a single pass:

JavaScript

Ctrl+Enter to run

// Standard pipeline — 3 passes, 2 intermediate arrays
function standardPipeline(data) {
  return data
    .filter(n => n % 2 === 0)     // intermediate array 1
    .map(n => n * n)              // intermediate array 2
    .reduce((a, b) => a + b, 0); // final value
}

// Transducer — compose the reducers, single pass, no intermediate arrays
const filtering = pred => reducer => (acc, val) =>
pred(val) ? reducer(acc, val) : acc;

const mapping = fn => reducer => (acc, val) =>
reducer(acc, fn(val));

const transduce = (xf, reducer, init, data) =>
data.reduce(xf(reducer), init);

// Same logic — even/square/sum — but composed into one reducer
const xf = fn => fn; // identity — we chain manually

const evenFilter = filtering(n => n % 2 === 0);
const squareMap = mapping(n => n * n);
const sumReducer = (acc, val) => acc + val;

// Compose: filter then map, applied to sumReducer
const composed = evenFilter(squareMap(sumReducer));

const data = Array.from({ length: 20 }, (_, i) => i + 1);

const standard = standardPipeline(data);
const transduced = data.reduce(composed, 0);

console.log("Standard: ", standard);
console.log("Transduced: ", transduced);
console.log("Same result:", standard === transduced);
console.log("\nTransducer: one pass, no intermediate arrays, any size data");

// Standard pipeline — 3 passes, 2 intermediate arrays
function standardPipeline(data) {
  return data
    .filter(n => n % 2 === 0)     // intermediate array 1
    .map(n => n * n)              // intermediate array 2
    .reduce((a, b) => a + b, 0); // final value
}

// Transducer — compose the reducers, single pass, no intermediate arrays
const filtering = pred => reducer => (acc, val) =>
pred(val) ? reducer(acc, val) : acc;

const mapping = fn => reducer => (acc, val) =>
reducer(acc, fn(val));

const transduce = (xf, reducer, init, data) =>
data.reduce(xf(reducer), init);

// Same logic — even/square/sum — but composed into one reducer
const xf = fn => fn; // identity — we chain manually

const evenFilter = filtering(n => n % 2 === 0);
const squareMap = mapping(n => n * n);
const sumReducer = (acc, val) => acc + val;

// Compose: filter then map, applied to sumReducer
const composed = evenFilter(squareMap(sumReducer));

const data = Array.from({ length: 20 }, (_, i) => i + 1);

const standard = standardPipeline(data);
const transduced = data.reduce(composed, 0);

console.log("Standard: ", standard);
console.log("Transduced: ", transduced);
console.log("Same result:", standard === transduced);
console.log("\nTransducer: one pass, no intermediate arrays, any size data");

For small arrays the difference is negligible. For large datasets — hundreds of thousands of records, complex pipelines — transducers eliminate allocation pressure entirely.

What You Have Learned

Functional programming is a discipline, not a religion. You do not need to abandon all mutation — you need to know where mutation causes problems and replace it with functional patterns in those places.

The key ideas:

Pure functions: same input → same output, no side effects — the atomic unit of FP
Immutability: spread to update, filter/map to modify arrays — originals never touched
Composition with pipe / compose: small functions assembled into pipelines
Currying: functions that take arguments one at a time, enabling partial application and reusable specialised callbacks
Functors: containers implementing map — transform the value without leaving the container
Maybe monad: null-safe pipelines — absent values propagate automatically, no null checks scattered through logic
Either monad: typed error handling — errors as values, composable, no try/catch in business logic
Transducers: compose filter/map logic into a single reducing function — one pass, no intermediate allocation

In the next lesson: Concurrency Patterns — beyond async/await. Task queues, semaphores, rate limiters, and the patterns that let you coordinate dozens of simultaneous async operations without race conditions, deadlocks, or server overload.

Functional Programming Patterns

The Core Claim

Pure Functions — The Foundation

Immutability — Never Change, Always Create

Function Composition — Building Pipelines

Currying — Functions That Return Functions

Functors — Mappable Containers

Maybe — Safe Navigation Without null Checks

Either — Typed Error Handling

Transducer — Composition Without Intermediate Arrays

What You Have Learned